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_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *self){
 903          return self->Empty();
 904       }
 905 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *self){
 906         return self->GetConnectionCount();
 907       }
 908 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Actor,Dali::TouchEvent const &)){
 909         self->Connect( func );
 910       }
 911 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Actor,Dali::TouchEvent const &)){
 912         self->Disconnect( func );
 913       }
 914 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,Dali::Actor arg1,Dali::TouchEvent const &arg2){
 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_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 980          return self->Empty();
 981       }
 982 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 983         return self->GetConnectionCount();
 984       }
 985 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchEvent const &) > *self,void (*func)(Dali::TouchEvent const &)){
 986           self->Connect( func );
 987       }
 988 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchEvent const &) > *self,void (*func)(Dali::TouchEvent const &)){
 989           self->Disconnect( func );
 990       }
 991 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchEvent const &) > *self,Dali::TouchEvent const &arg){
 992           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 993 /*@SWIG@*/ self->Emit( arg );
 994       }
 995 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 996          return self->Empty();
 997       }
 998 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 999         return self->GetConnectionCount();
1000       }
1001 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1002           self->Connect( func );
1003       }
1004 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1005           self->Disconnect( func );
1006       }
1007 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
1008           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1009 /*@SWIG@*/ self->Emit( arg );
1010       }
1011 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1012          return self->Empty();
1013       }
1014 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1015         return self->GetConnectionCount();
1016       }
1017 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1018         self->Connect( func );
1019       }
1020 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1021         self->Disconnect( func );
1022       }
1023 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
1024         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1025 /*@SWIG@*/ self->Emit( arg1, arg2 );
1026       }
1027 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1028          return self->Empty();
1029       }
1030 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1031         return self->GetConnectionCount();
1032       }
1033 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1034         self->Connect( func );
1035       }
1036 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1037         self->Disconnect( func );
1038       }
1039 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
1040         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1041 /*@SWIG@*/ self->Emit( arg1, arg2 );
1042       }
1043 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1044          return self->Empty();
1045       }
1046 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1047         return self->GetConnectionCount();
1048       }
1049 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1050         self->Connect( func );
1051       }
1052 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1053         self->Disconnect( func );
1054       }
1055 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
1056         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1057 /*@SWIG@*/ self->Emit( arg1, arg2 );
1058       }
1059 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1060          return self->Empty();
1061       }
1062 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1063         return self->GetConnectionCount();
1064       }
1065 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1066           return self->Connect( func );
1067       }
1068 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1069           self->Disconnect( func );
1070       }
1071 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){
1072           self->Emit( arg1, arg3 );
1073       }
1074 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1075          return self->Empty();
1076       }
1077 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1078         return self->GetConnectionCount();
1079       }
1080 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1081           return self->Connect( func );
1082       }
1083 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1084           self->Disconnect( func );
1085       }
1086 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1087           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1088 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1089       }
1090
1091 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1092          return self->Empty();
1093       }
1094 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1095         return self->GetConnectionCount();
1096       }
1097 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1098           self->Connect( func );
1099       }
1100 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1101           self->Disconnect( func );
1102       }
1103 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1104           return self->Emit();
1105       }
1106
1107 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1108         std::vector< unsigned int >* pv = 0;
1109         if (capacity >= 0) {
1110           pv = new std::vector< unsigned int >();
1111           pv->reserve(capacity);
1112        } else {
1113           throw std::out_of_range("capacity");
1114        }
1115        return pv;
1116       }
1117 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1118         if (index>=0 && index<(int)self->size())
1119           return (*self)[index];
1120         else
1121           throw std::out_of_range("index");
1122       }
1123 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1124         if (index>=0 && index<(int)self->size())
1125           return (*self)[index];
1126         else
1127           throw std::out_of_range("index");
1128       }
1129 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1130         if (index>=0 && index<(int)self->size())
1131           (*self)[index] = val;
1132         else
1133           throw std::out_of_range("index");
1134       }
1135 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1136         self->insert(self->end(), values.begin(), values.end());
1137       }
1138 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1139         if (index < 0)
1140           throw std::out_of_range("index");
1141         if (count < 0)
1142           throw std::out_of_range("count");
1143         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1144           throw std::invalid_argument("invalid range");
1145         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1146       }
1147 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1148         if (index>=0 && index<(int)self->size()+1)
1149           self->insert(self->begin()+index, x);
1150         else
1151           throw std::out_of_range("index");
1152       }
1153 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1154         if (index>=0 && index<(int)self->size()+1)
1155           self->insert(self->begin()+index, values.begin(), values.end());
1156         else
1157           throw std::out_of_range("index");
1158       }
1159 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1160         if (index>=0 && index<(int)self->size())
1161           self->erase(self->begin() + index);
1162         else
1163           throw std::out_of_range("index");
1164       }
1165 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1166         if (index < 0)
1167           throw std::out_of_range("index");
1168         if (count < 0)
1169           throw std::out_of_range("count");
1170         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1171           throw std::invalid_argument("invalid range");
1172         self->erase(self->begin()+index, self->begin()+index+count);
1173       }
1174 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1175         if (count < 0)
1176           throw std::out_of_range("count");
1177         return new std::vector< unsigned int >(count, value);
1178       }
1179 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1180         std::reverse(self->begin(), self->end());
1181       }
1182 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1183         if (index < 0)
1184           throw std::out_of_range("index");
1185         if (count < 0)
1186           throw std::out_of_range("count");
1187         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1188           throw std::invalid_argument("invalid range");
1189         std::reverse(self->begin()+index, self->begin()+index+count);
1190       }
1191 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1192         if (index < 0)
1193           throw std::out_of_range("index");
1194         if (index+values.size() > self->size())
1195           throw std::out_of_range("index");
1196         std::copy(values.begin(), values.end(), self->begin()+index);
1197       }
1198 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1199         return std::find(self->begin(), self->end(), value) != self->end();
1200       }
1201 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1202         int index = -1;
1203         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1204         if (it != self->end())
1205           index = (int)(it - self->begin());
1206         return index;
1207       }
1208 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1209         int index = -1;
1210         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1211         if (rit != self->rend())
1212           index = (int)(self->rend() - 1 - rit);
1213         return index;
1214       }
1215 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1216         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1217         if (it != self->end()) {
1218           self->erase(it);
1219           return true;
1220         }
1221         return false;
1222       }
1223 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1224         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1225         if (capacity >= 0) {
1226           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1227           pv->reserve(capacity);
1228        } else {
1229           throw std::out_of_range("capacity");
1230        }
1231        return pv;
1232       }
1233 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1234         if (index>=0 && index<(int)self->size())
1235           return (*self)[index];
1236         else
1237           throw std::out_of_range("index");
1238       }
1239 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1240         if (index>=0 && index<(int)self->size())
1241           return (*self)[index];
1242         else
1243           throw std::out_of_range("index");
1244       }
1245 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1246         if (index>=0 && index<(int)self->size())
1247           (*self)[index] = val;
1248         else
1249           throw std::out_of_range("index");
1250       }
1251 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1252         self->insert(self->end(), values.begin(), values.end());
1253       }
1254 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1255         if (index < 0)
1256           throw std::out_of_range("index");
1257         if (count < 0)
1258           throw std::out_of_range("count");
1259         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1260           throw std::invalid_argument("invalid range");
1261         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1262       }
1263 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1264         if (index>=0 && index<(int)self->size()+1)
1265           self->insert(self->begin()+index, x);
1266         else
1267           throw std::out_of_range("index");
1268       }
1269 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1270         if (index>=0 && index<(int)self->size()+1)
1271           self->insert(self->begin()+index, values.begin(), values.end());
1272         else
1273           throw std::out_of_range("index");
1274       }
1275 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1276         if (index>=0 && index<(int)self->size())
1277           self->erase(self->begin() + index);
1278         else
1279           throw std::out_of_range("index");
1280       }
1281 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1282         if (index < 0)
1283           throw std::out_of_range("index");
1284         if (count < 0)
1285           throw std::out_of_range("count");
1286         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1287           throw std::invalid_argument("invalid range");
1288         self->erase(self->begin()+index, self->begin()+index+count);
1289       }
1290 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1291         if (count < 0)
1292           throw std::out_of_range("count");
1293         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1294       }
1295 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1296         std::reverse(self->begin(), self->end());
1297       }
1298 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1299         if (index < 0)
1300           throw std::out_of_range("index");
1301         if (count < 0)
1302           throw std::out_of_range("count");
1303         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1304           throw std::invalid_argument("invalid range");
1305         std::reverse(self->begin()+index, self->begin()+index+count);
1306       }
1307 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1308         if (index < 0)
1309           throw std::out_of_range("index");
1310         if (index+values.size() > self->size())
1311           throw std::out_of_range("index");
1312         std::copy(values.begin(), values.end(), self->begin()+index);
1313       }
1314 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1315         std::vector< Dali::Actor >* pv = 0;
1316         if (capacity >= 0) {
1317           pv = new std::vector< Dali::Actor >();
1318           pv->reserve(capacity);
1319        } else {
1320           throw std::out_of_range("capacity");
1321        }
1322        return pv;
1323       }
1324 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1325         if (index>=0 && index<(int)self->size())
1326           return (*self)[index];
1327         else
1328           throw std::out_of_range("index");
1329       }
1330 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1331         if (index>=0 && index<(int)self->size())
1332           return (*self)[index];
1333         else
1334           throw std::out_of_range("index");
1335       }
1336 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1337         if (index>=0 && index<(int)self->size())
1338           (*self)[index] = val;
1339         else
1340           throw std::out_of_range("index");
1341       }
1342 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1343         self->insert(self->end(), values.begin(), values.end());
1344       }
1345 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1346         if (index < 0)
1347           throw std::out_of_range("index");
1348         if (count < 0)
1349           throw std::out_of_range("count");
1350         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1351           throw std::invalid_argument("invalid range");
1352         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1353       }
1354 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1355         if (index>=0 && index<(int)self->size()+1)
1356           self->insert(self->begin()+index, x);
1357         else
1358           throw std::out_of_range("index");
1359       }
1360 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1361         if (index>=0 && index<(int)self->size()+1)
1362           self->insert(self->begin()+index, values.begin(), values.end());
1363         else
1364           throw std::out_of_range("index");
1365       }
1366 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1367         if (index>=0 && index<(int)self->size())
1368           self->erase(self->begin() + index);
1369         else
1370           throw std::out_of_range("index");
1371       }
1372 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1373         if (index < 0)
1374           throw std::out_of_range("index");
1375         if (count < 0)
1376           throw std::out_of_range("count");
1377         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1378           throw std::invalid_argument("invalid range");
1379         self->erase(self->begin()+index, self->begin()+index+count);
1380       }
1381 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1382         if (count < 0)
1383           throw std::out_of_range("count");
1384         return new std::vector< Dali::Actor >(count, value);
1385       }
1386 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1387         std::reverse(self->begin(), self->end());
1388       }
1389 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1390         if (index < 0)
1391           throw std::out_of_range("index");
1392         if (count < 0)
1393           throw std::out_of_range("count");
1394         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1395           throw std::invalid_argument("invalid range");
1396         std::reverse(self->begin()+index, self->begin()+index+count);
1397       }
1398 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1399         if (index < 0)
1400           throw std::out_of_range("index");
1401         if (index+values.size() > self->size())
1402           throw std::out_of_range("index");
1403         std::copy(values.begin(), values.end(), self->begin()+index);
1404       }
1405 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1406          return self->Empty();
1407       }
1408 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1409         return self->GetConnectionCount();
1410       }
1411 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1412           self->Connect( func );
1413       }
1414 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1415           self->Disconnect( func );
1416       }
1417 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1418           return self->Emit( arg );
1419       }
1420 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1421          return self->Empty();
1422       }
1423 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1424         return self->GetConnectionCount();
1425       }
1426 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1427         self->Connect( func );
1428       }
1429 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1430         self->Disconnect( func );
1431       }
1432 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1433         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1434 /*@SWIG@*/ self->Emit( arg1, arg2 );
1435       }
1436 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1437          return self->Empty();
1438       }
1439 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1440         return self->GetConnectionCount();
1441       }
1442 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1443         self->Connect( func );
1444       }
1445 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1446         self->Disconnect( func );
1447       }
1448 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1449         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1450 /*@SWIG@*/ self->Emit( arg1, arg2 );
1451       }
1452 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1453          return self->Empty();
1454       }
1455 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1456         return self->GetConnectionCount();
1457       }
1458 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1459         self->Connect( func );
1460       }
1461 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1462         self->Disconnect( func );
1463       }
1464 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1465         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1466 /*@SWIG@*/ self->Emit( arg1, arg2 );
1467       }
1468 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1469          return self->Empty();
1470       }
1471 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1472         return self->GetConnectionCount();
1473       }
1474 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1475         self->Connect( func );
1476       }
1477 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1478         self->Disconnect( func );
1479       }
1480 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1481         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1482 /*@SWIG@*/ self->Emit( arg1, arg2 );
1483       }
1484 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1485          return self->Empty();
1486       }
1487 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1488         return self->GetConnectionCount();
1489       }
1490 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1491           self->Connect( func );
1492       }
1493 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1494           self->Disconnect( func );
1495       }
1496 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1497           return self->Emit( arg );
1498       }
1499 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1500          return self->Empty();
1501       }
1502 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1503         return self->GetConnectionCount();
1504       }
1505 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1506           self->Connect( func );
1507       }
1508 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1509           self->Disconnect( func );
1510       }
1511 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1512           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1513 /*@SWIG@*/ self->Emit( arg );
1514       }
1515 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1516          return self->Empty();
1517       }
1518 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1519         return self->GetConnectionCount();
1520       }
1521 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1522           return self->Connect( func );
1523       }
1524 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1525           self->Disconnect( func );
1526       }
1527 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1528           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1529 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1530       }
1531 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1532          return self->Empty();
1533       }
1534 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1535         return self->GetConnectionCount();
1536       }
1537 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1538           self->Connect( func );
1539       }
1540 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1541           self->Disconnect( func );
1542       }
1543 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1544           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1545 /*@SWIG@*/ self->Emit( arg );
1546       }
1547 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1548          return self->Empty();
1549       }
1550 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1551         return self->GetConnectionCount();
1552       }
1553 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1554           return self->Connect( func );
1555       }
1556 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1557           self->Disconnect( func );
1558       }
1559 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1560           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1561 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1562       }
1563 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1564          return self->Empty();
1565       }
1566 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1567         return self->GetConnectionCount();
1568       }
1569 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1570           self->Connect( func );
1571       }
1572 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1573           self->Disconnect( func );
1574       }
1575 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1576           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1577 /*@SWIG@*/ self->Emit( arg );
1578       }
1579 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1580          return self->Empty();
1581       }
1582 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1583         return self->GetConnectionCount();
1584       }
1585 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1586           self->Connect( func );
1587       }
1588 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1589           self->Disconnect( func );
1590       }
1591 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1592           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1593 /*@SWIG@*/ self->Emit( arg );
1594       }
1595
1596
1597 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1598          return self->Empty();
1599       }
1600 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1601         return self->GetConnectionCount();
1602       }
1603 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1604         self->Connect( func );
1605       }
1606 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1607         self->Disconnect( func );
1608       }
1609 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1610         return self->Emit( arg1, arg2 );
1611       }
1612 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1613          return self->Empty();
1614       }
1615 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1616         return self->GetConnectionCount();
1617       }
1618 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1619           self->Connect( func );
1620       }
1621 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1622           self->Disconnect( func );
1623       }
1624 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1625           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1626 /*@SWIG@*/ self->Emit( arg );
1627       }
1628 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1629          return self->Empty();
1630       }
1631 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1632         return self->GetConnectionCount();
1633       }
1634 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1635           self->Connect( func );
1636       }
1637 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1638           self->Disconnect( func );
1639       }
1640 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1641           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1642 /*@SWIG@*/ self->Emit( arg );
1643       }
1644 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1645          return self->Empty();
1646       }
1647 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1648         return self->GetConnectionCount();
1649       }
1650 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1651         self->Connect( func );
1652       }
1653 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1654         self->Disconnect( func );
1655       }
1656 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1657         return self->Emit( arg1, arg2 );
1658       }
1659 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1660          return self->Empty();
1661       }
1662 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1663         return self->GetConnectionCount();
1664       }
1665 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1666         self->Connect( func );
1667       }
1668 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1669         self->Disconnect( func );
1670       }
1671 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1672         return self->Emit( arg1, arg2 );
1673       }
1674
1675 /* ---------------------------------------------------
1676  * C++ director class methods
1677  * --------------------------------------------------- */
1678
1679 #include "dali_wrap.h"
1680
1681 /*
1682  *  Widget director
1683  */
1684 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1685   swig_init_callbacks();
1686 }
1687
1688 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1689 }
1690
1691 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1692   char * jcontentInfo = 0 ;
1693   void * jwindow  ;
1694
1695   if (!swig_callbackOnCreate) {
1696     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1697     return;
1698   } else {
1699     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1700     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1701     swig_callbackOnCreate(jcontentInfo, jwindow);
1702   }
1703 }
1704
1705 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1706   char * jcontentInfo = 0 ;
1707   int jtype  ;
1708
1709   if (!swig_callbackOnTerminate) {
1710     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1711     return;
1712   } else {
1713     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1714     jtype = (int)type;
1715     swig_callbackOnTerminate(jcontentInfo, jtype);
1716   }
1717 }
1718
1719 void SwigDirector_WidgetImpl::OnPause() {
1720   if (!swig_callbackOnPause) {
1721     Dali::Internal::Adaptor::Widget::OnPause();
1722     return;
1723   } else {
1724     swig_callbackOnPause();
1725   }
1726 }
1727
1728 void SwigDirector_WidgetImpl::OnResume() {
1729   if (!swig_callbackOnResume) {
1730     Dali::Internal::Adaptor::Widget::OnResume();
1731     return;
1732   } else {
1733     swig_callbackOnResume();
1734   }
1735 }
1736
1737 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1738   void * jwindow  ;
1739
1740   if (!swig_callbackOnResize) {
1741     Dali::Internal::Adaptor::Widget::OnResize(window);
1742     return;
1743   } else {
1744     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1745     swig_callbackOnResize(jwindow);
1746   }
1747 }
1748
1749 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1750   char * jcontentInfo = 0 ;
1751   int jforce  ;
1752
1753   if (!swig_callbackOnUpdate) {
1754     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1755     return;
1756   } else {
1757     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1758     jforce = force;
1759     swig_callbackOnUpdate(jcontentInfo, jforce);
1760   }
1761 }
1762
1763 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1764   void * jslotObserver = 0 ;
1765   void * jcallback = 0 ;
1766
1767   if (!swig_callbackSignalConnected) {
1768     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1769     return;
1770   } else {
1771     jslotObserver = (void *) slotObserver;
1772     jcallback = (void *) callback;
1773     swig_callbackSignalConnected(jslotObserver, jcallback);
1774   }
1775 }
1776
1777 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1778   void * jslotObserver = 0 ;
1779   void * jcallback = 0 ;
1780
1781   if (!swig_callbackSignalDisconnected) {
1782     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1783     return;
1784   } else {
1785     jslotObserver = (void *) slotObserver;
1786     jcallback = (void *) callback;
1787     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1788   }
1789 }
1790
1791 void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) {
1792
1793   swig_callbackOnCreate = callbackOnCreate;
1794   swig_callbackOnTerminate = callbackOnTerminate;
1795   swig_callbackOnPause = callbackOnPause;
1796   swig_callbackOnResume = callbackOnResume;
1797   swig_callbackOnResize = callbackOnResize;
1798   swig_callbackOnUpdate = callbackOnUpdate;
1799   swig_callbackSignalConnected = callbackSignalConnected;
1800   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1801 }
1802
1803 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1804   swig_callbackOnCreate = 0;
1805   swig_callbackOnTerminate = 0;
1806   swig_callbackOnPause = 0;
1807   swig_callbackOnResume = 0;
1808   swig_callbackOnResize = 0;
1809   swig_callbackOnUpdate = 0;
1810   swig_callbackSignalConnected = 0;
1811   swig_callbackSignalDisconnected = 0;
1812 }
1813
1814
1815 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1816   swig_init_callbacks();
1817 }
1818
1819 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1820
1821 }
1822
1823
1824 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1825   int jdepth  ;
1826
1827   if (!swig_callbackOnSceneConnection) {
1828     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1829     return;
1830   } else {
1831     jdepth = depth;
1832     swig_callbackOnSceneConnection(jdepth);
1833   }
1834 }
1835
1836 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1837   if (!swig_callbackOnSceneDisconnection) {
1838     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1839     return;
1840   } else {
1841     swig_callbackOnSceneDisconnection();
1842   }
1843 }
1844
1845 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1846   void * jchild = 0 ;
1847
1848   if (!swig_callbackOnChildAdd) {
1849     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1850     return;
1851   } else {
1852     jchild = (Dali::Actor *) &child;
1853     swig_callbackOnChildAdd(jchild);
1854   }
1855 }
1856
1857 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1858   void * jchild = 0 ;
1859
1860   if (!swig_callbackOnChildRemove) {
1861     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1862     return;
1863   } else {
1864     jchild = (Dali::Actor *) &child;
1865     swig_callbackOnChildRemove(jchild);
1866   }
1867 }
1868
1869 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1870   int jindex  ;
1871   void * jpropertyValue  ;
1872
1873   if (!swig_callbackOnPropertySet) {
1874     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1875     return;
1876   } else {
1877     jindex = index;
1878     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1879     swig_callbackOnPropertySet(jindex, jpropertyValue);
1880   }
1881 }
1882
1883 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1884   void * jtargetSize = 0 ;
1885
1886   if (!swig_callbackOnSizeSet) {
1887     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1888     return;
1889   } else {
1890     jtargetSize = (Dali::Vector3 *) &targetSize;
1891     swig_callbackOnSizeSet(jtargetSize);
1892   }
1893 }
1894
1895 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1896   void * janimation = 0 ;
1897   void * jtargetSize = 0 ;
1898
1899   if (!swig_callbackOnSizeAnimation) {
1900     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1901     return;
1902   } else {
1903     janimation = (Dali::Animation *) &animation;
1904     jtargetSize = (Dali::Vector3 *) &targetSize;
1905     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1906   }
1907 }
1908
1909 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1910   bool c_result = SwigValueInit< bool >() ;
1911   unsigned int jresult = 0 ;
1912   void * jarg0 = 0 ;
1913
1914   if (!swig_callbackOnHoverEvent) {
1915     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1916   } else {
1917     jarg0 = (Dali::HoverEvent *) &event;
1918     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1919     c_result = jresult ? true : false;
1920   }
1921   return c_result;
1922 }
1923
1924 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1925   bool c_result = SwigValueInit< bool >() ;
1926   unsigned int jresult = 0 ;
1927   void * jarg0 = 0 ;
1928
1929   if (!swig_callbackOnKeyEvent) {
1930     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1931   } else {
1932     jarg0 = (Dali::KeyEvent *) &event;
1933     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1934     c_result = jresult ? true : false;
1935   }
1936   return c_result;
1937 }
1938
1939 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1940   bool c_result = SwigValueInit< bool >() ;
1941   unsigned int jresult = 0 ;
1942   void * jarg0 = 0 ;
1943
1944   if (!swig_callbackOnWheelEvent) {
1945     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1946   } else {
1947     jarg0 = (Dali::WheelEvent *) &event;
1948     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1949     c_result = jresult ? true : false;
1950   }
1951   return c_result;
1952 }
1953
1954 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1955   void * jsize = 0 ;
1956   void * jcontainer = 0 ;
1957
1958   if (!swig_callbackOnRelayout) {
1959     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1960     return;
1961   } else {
1962     jsize = (Dali::Vector2 *) &size;
1963     jcontainer = (Dali::RelayoutContainer *) &container;
1964     swig_callbackOnRelayout(jsize, jcontainer);
1965   }
1966 }
1967
1968 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1969   int jpolicy  ;
1970   int jdimension  ;
1971
1972   if (!swig_callbackOnSetResizePolicy) {
1973     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1974     return;
1975   } else {
1976     jpolicy = (int)policy;
1977     jdimension = (int)dimension;
1978     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1979   }
1980 }
1981
1982 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1983   Dali::Vector3 c_result ;
1984   void * jresult = 0 ;
1985
1986   if (!swig_callbackGetNaturalSize) {
1987     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1988   } else {
1989     jresult = (void *) swig_callbackGetNaturalSize();
1990     if (!jresult) {
1991       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1992       return c_result;
1993     }
1994     c_result = *(Dali::Vector3 *)jresult;
1995   }
1996   return c_result;
1997 }
1998
1999 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2000   float c_result = SwigValueInit< float >() ;
2001   float jresult = 0 ;
2002   void * jchild = 0 ;
2003   int jdimension  ;
2004
2005   if (!swig_callbackCalculateChildSize) {
2006     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2007   } else {
2008     jchild = (Dali::Actor *) &child;
2009     jdimension = (int)dimension;
2010     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2011     c_result = (float)jresult;
2012   }
2013   return c_result;
2014 }
2015
2016 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2017   float c_result = SwigValueInit< float >() ;
2018   float jresult = 0 ;
2019   float jwidth  ;
2020
2021   if (!swig_callbackGetHeightForWidth) {
2022     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2023   } else {
2024     jwidth = width;
2025     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2026     c_result = (float)jresult;
2027   }
2028   return c_result;
2029 }
2030
2031 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2032   float c_result = SwigValueInit< float >() ;
2033   float jresult = 0 ;
2034   float jheight  ;
2035
2036   if (!swig_callbackGetWidthForHeight) {
2037     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2038   } else {
2039     jheight = height;
2040     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2041     c_result = (float)jresult;
2042   }
2043   return c_result;
2044 }
2045
2046 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2047   bool c_result = SwigValueInit< bool >() ;
2048   unsigned int jresult = 0 ;
2049   int jdimension  ;
2050
2051   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2052     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2053   } else {
2054     jdimension = (int)dimension;
2055     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2056     c_result = jresult ? true : false;
2057   }
2058   return c_result;
2059 }
2060
2061 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2062   int jdimension  ;
2063
2064   if (!swig_callbackOnCalculateRelayoutSize) {
2065     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2066     return;
2067   } else {
2068     jdimension = (int)dimension;
2069     swig_callbackOnCalculateRelayoutSize(jdimension);
2070   }
2071 }
2072
2073 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2074   float jsize  ;
2075   int jdimension  ;
2076
2077   if (!swig_callbackOnLayoutNegotiated) {
2078     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2079     return;
2080   } else {
2081     jsize = size;
2082     jdimension = (int)dimension;
2083     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2084   }
2085 }
2086
2087 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2088   return Dali::CustomActorImpl::GetExtension();
2089 }
2090
2091 void SwigDirector_ViewImpl::OnInitialize() {
2092   if (!swig_callbackOnInitialize) {
2093     Dali::Toolkit::Internal::Control::OnInitialize();
2094     return;
2095   } else {
2096     swig_callbackOnInitialize();
2097   }
2098 }
2099
2100 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2101   void * jstyleManager  ;
2102   int jchange  ;
2103
2104   if (!swig_callbackOnStyleChange) {
2105     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2106     return;
2107   } else {
2108     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2109     jchange = (int)change;
2110     swig_callbackOnStyleChange(jstyleManager, jchange);
2111   }
2112 }
2113
2114 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2115   bool c_result = SwigValueInit< bool >() ;
2116   unsigned int jresult = 0 ;
2117
2118   if (!swig_callbackOnAccessibilityActivated) {
2119     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2120   } else {
2121     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2122     c_result = jresult ? true : false;
2123   }
2124   return c_result;
2125 }
2126
2127 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2128   bool c_result = SwigValueInit< bool >() ;
2129   unsigned int jresult = 0 ;
2130   void * jgesture  ;
2131
2132   if (!swig_callbackOnAccessibilityPan) {
2133     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2134   } else {
2135     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2136     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2137     c_result = jresult ? true : false;
2138   }
2139   return c_result;
2140 }
2141
2142 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touch) {
2143   bool c_result = SwigValueInit< bool >() ;
2144   unsigned int jresult = 0 ;
2145   void * jtouch = 0 ;
2146
2147   if (!swig_callbackOnAccessibilityTouch) {
2148     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touch);
2149   } else {
2150     jtouch = (Dali::TouchEvent *) &touch;
2151     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouch);
2152     c_result = jresult ? true : false;
2153   }
2154   return c_result;
2155 }
2156
2157 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2158   bool c_result = SwigValueInit< bool >() ;
2159   unsigned int jresult = 0 ;
2160   unsigned int jisIncrease  ;
2161
2162   if (!swig_callbackOnAccessibilityValueChange) {
2163     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2164   } else {
2165     jisIncrease = isIncrease;
2166     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2167     c_result = jresult ? true : false;
2168   }
2169   return c_result;
2170 }
2171
2172 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2173   bool c_result = SwigValueInit< bool >() ;
2174   unsigned int jresult = 0 ;
2175
2176   if (!swig_callbackOnAccessibilityZoom) {
2177     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2178   } else {
2179     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2180     c_result = jresult ? true : false;
2181   }
2182   return c_result;
2183 }
2184
2185 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2186   if (!swig_callbackOnKeyInputFocusGained) {
2187     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2188     return;
2189   } else {
2190     swig_callbackOnKeyInputFocusGained();
2191   }
2192 }
2193
2194 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2195   if (!swig_callbackOnKeyInputFocusLost) {
2196     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2197     return;
2198   } else {
2199     swig_callbackOnKeyInputFocusLost();
2200   }
2201 }
2202
2203 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2204   Dali::Actor c_result ;
2205   void * jresult = 0 ;
2206   void * jcurrentFocusedActor  ;
2207   int jdirection  ;
2208   unsigned int jloopEnabled  ;
2209
2210   if (!swig_callbackGetNextKeyboardFocusableActor) {
2211     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2212   } else {
2213     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2214     jdirection = (int)direction;
2215     jloopEnabled = loopEnabled;
2216     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2217     if (!jresult) {
2218       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2219       return c_result;
2220     }
2221     c_result = *(Dali::Actor *)jresult;
2222   }
2223   return c_result;
2224 }
2225
2226 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2227   void * jcommitedFocusableActor  ;
2228
2229   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2230     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2231     return;
2232   } else {
2233     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2234     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2235   }
2236 }
2237
2238 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2239   bool c_result = SwigValueInit< bool >() ;
2240   unsigned int jresult = 0 ;
2241
2242   if (!swig_callbackOnKeyboardEnter) {
2243     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2244   } else {
2245     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2246     c_result = jresult ? true : false;
2247   }
2248   return c_result;
2249 }
2250
2251 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2252   void * jpinch = 0 ;
2253
2254   if (!swig_callbackOnPinch) {
2255     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2256     return;
2257   } else {
2258     jpinch = (Dali::PinchGesture *) &pinch;
2259     swig_callbackOnPinch(jpinch);
2260   }
2261 }
2262
2263 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2264   void * jpan = 0 ;
2265
2266   if (!swig_callbackOnPan) {
2267     Dali::Toolkit::Internal::Control::OnPan(pan);
2268     return;
2269   } else {
2270     jpan = (Dali::PanGesture *) &pan;
2271     swig_callbackOnPan(jpan);
2272   }
2273 }
2274
2275 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2276   void * jtap = 0 ;
2277
2278   if (!swig_callbackOnTap) {
2279     Dali::Toolkit::Internal::Control::OnTap(tap);
2280     return;
2281   } else {
2282     jtap = (Dali::TapGesture *) &tap;
2283     swig_callbackOnTap(jtap);
2284   }
2285 }
2286
2287 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2288   void * jlongPress = 0 ;
2289
2290   if (!swig_callbackOnLongPress) {
2291     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2292     return;
2293   } else {
2294     jlongPress = (Dali::LongPressGesture *) &longPress;
2295     swig_callbackOnLongPress(jlongPress);
2296   }
2297 }
2298
2299 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2300   void * jslotObserver = 0 ;
2301   void * jcallback = 0 ;
2302
2303   if (!swig_callbackSignalConnected) {
2304     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2305     return;
2306   } else {
2307     jslotObserver = (void *) slotObserver;
2308     jcallback = (void *) callback;
2309     swig_callbackSignalConnected(jslotObserver, jcallback);
2310   }
2311 }
2312
2313 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2314   void * jslotObserver = 0 ;
2315   void * jcallback = 0 ;
2316
2317   if (!swig_callbackSignalDisconnected) {
2318     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2319     return;
2320   } else {
2321     jslotObserver = (void *) slotObserver;
2322     jcallback = (void *) callback;
2323     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2324   }
2325 }
2326
2327 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2328   return Dali::Toolkit::Internal::Control::GetControlExtension();
2329 }
2330
2331 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnSceneConnection, SWIG_Callback1_t callbackOnSceneDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2332   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2333   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2334   swig_callbackOnChildAdd = callbackOnChildAdd;
2335   swig_callbackOnChildRemove = callbackOnChildRemove;
2336   swig_callbackOnPropertySet = callbackOnPropertySet;
2337   swig_callbackOnSizeSet = callbackOnSizeSet;
2338   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2339   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2340   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2341   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2342   swig_callbackOnRelayout = callbackOnRelayout;
2343   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2344   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2345   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2346   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2347   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2348   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2349   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2350   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2351   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2352   swig_callbackOnInitialize = callbackOnInitialize;
2353   swig_callbackOnStyleChange = callbackOnStyleChange;
2354   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2355   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2356   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2357   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2358   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2359   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2360   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2361   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2362   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2363   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2364   swig_callbackOnPinch = callbackOnPinch;
2365   swig_callbackOnPan = callbackOnPan;
2366   swig_callbackOnTap = callbackOnTap;
2367   swig_callbackOnLongPress = callbackOnLongPress;
2368   swig_callbackSignalConnected = callbackSignalConnected;
2369   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2370 }
2371
2372 void SwigDirector_ViewImpl::swig_init_callbacks() {
2373   swig_callbackOnSceneConnection = 0;
2374   swig_callbackOnSceneDisconnection = 0;
2375   swig_callbackOnChildAdd = 0;
2376   swig_callbackOnChildRemove = 0;
2377   swig_callbackOnPropertySet = 0;
2378   swig_callbackOnSizeSet = 0;
2379   swig_callbackOnSizeAnimation = 0;
2380   swig_callbackOnHoverEvent = 0;
2381   swig_callbackOnKeyEvent = 0;
2382   swig_callbackOnWheelEvent = 0;
2383   swig_callbackOnRelayout = 0;
2384   swig_callbackOnSetResizePolicy = 0;
2385   swig_callbackGetNaturalSize = 0;
2386   swig_callbackCalculateChildSize = 0;
2387   swig_callbackGetHeightForWidth = 0;
2388   swig_callbackGetWidthForHeight = 0;
2389   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2390   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2391   swig_callbackOnCalculateRelayoutSize = 0;
2392   swig_callbackOnLayoutNegotiated = 0;
2393   swig_callbackOnInitialize = 0;
2394   swig_callbackOnStyleChange = 0;
2395   swig_callbackOnAccessibilityActivated = 0;
2396   swig_callbackOnAccessibilityPan = 0;
2397   swig_callbackOnAccessibilityTouch = 0;
2398   swig_callbackOnAccessibilityValueChange = 0;
2399   swig_callbackOnAccessibilityZoom = 0;
2400   swig_callbackOnKeyInputFocusGained = 0;
2401   swig_callbackOnKeyInputFocusLost = 0;
2402   swig_callbackGetNextKeyboardFocusableActor = 0;
2403   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2404   swig_callbackOnKeyboardEnter = 0;
2405   swig_callbackOnPinch = 0;
2406   swig_callbackOnPan = 0;
2407   swig_callbackOnTap = 0;
2408   swig_callbackOnLongPress = 0;
2409   swig_callbackSignalConnected = 0;
2410   swig_callbackSignalDisconnected = 0;
2411 }
2412
2413 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2414   swig_init_callbacks();
2415 }
2416
2417 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2418
2419 }
2420
2421
2422 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2423   unsigned int c_result = SwigValueInit< unsigned int >() ;
2424   unsigned int jresult = 0 ;
2425
2426   if (!swig_callbackGetNumberOfItems) {
2427     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2428   } else {
2429     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2430     c_result = (unsigned int)jresult;
2431   }
2432   return c_result;
2433 }
2434
2435 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2436   Dali::Actor c_result ;
2437   void * jresult = 0 ;
2438   unsigned int jitemId  ;
2439
2440   if (!swig_callbackNewItem) {
2441     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2442   } else {
2443     jitemId = itemId;
2444     jresult = (void *) swig_callbackNewItem(jitemId);
2445     if (!jresult) {
2446       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2447       return c_result;
2448     }
2449     c_result = *(Dali::Actor *)jresult;
2450   }
2451   return c_result;
2452 }
2453
2454 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2455   unsigned int jitemId  ;
2456   void * jactor  ;
2457
2458   if (!swig_callbackItemReleased) {
2459     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2460     return;
2461   } else {
2462     jitemId = itemId;
2463     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2464     swig_callbackItemReleased(jitemId, jactor);
2465   }
2466 }
2467
2468 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2469   return Dali::Toolkit::ItemFactory::GetExtension();
2470 }
2471
2472 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2473   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2474   swig_callbackNewItem = callbackNewItem;
2475   swig_callbackItemReleased = callbackItemReleased;
2476 }
2477
2478 void SwigDirector_ItemFactory::swig_init_callbacks() {
2479   swig_callbackGetNumberOfItems = 0;
2480   swig_callbackNewItem = 0;
2481   swig_callbackItemReleased = 0;
2482 }
2483
2484 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2485   swig_init_callbacks();
2486 }
2487
2488 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2489
2490 }
2491
2492
2493 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2494   Dali::Actor c_result ;
2495   void * jresult = 0 ;
2496   void * jcurrent  ;
2497   void * jproposed  ;
2498   int jdirection  ;
2499
2500   if (!swig_callbackGetNextFocusableActor) {
2501     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2502   } else {
2503     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2504     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2505     jdirection = (int)direction;
2506     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2507     if (!jresult) {
2508       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::Actor! Next focus will be NULL, please be cautious to handle the keyboard foucs! ", __FILE__, __LINE__);
2509       return c_result;
2510     }
2511     c_result = *(Dali::Actor *)jresult;
2512   }
2513   return c_result;
2514 }
2515
2516 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2517   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2518 }
2519
2520 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2521   swig_callbackGetNextFocusableActor = 0;
2522 }
2523
2524 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
2525   swig_callbackOnUpdate = 0;
2526 }
2527
2528 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
2529
2530 }
2531
2532 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
2533   swig_callbackOnUpdate = callbackUpdate;
2534 }
2535
2536
2537 void SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
2538   void * jcurrent  ;
2539
2540   if (!swig_callbackOnUpdate) {
2541     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2542   } else {
2543     Dali::UpdateProxy* proxy = &updateProxy;
2544     jcurrent = (void *)proxy;
2545     swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2546     if (!jcurrent) {
2547       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2548       return;
2549     }
2550   }
2551   return;
2552 }
2553
2554
2555 #ifdef __cplusplus
2556 extern "C" {
2557 #endif
2558
2559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2560   void * jresult ;
2561   floatp *result = 0 ;
2562
2563   {
2564     try {
2565       result = (floatp *)new_floatp();
2566     } catch (std::out_of_range& e) {
2567       {
2568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2569       };
2570     } catch (std::exception& e) {
2571       {
2572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2573       };
2574     } catch (DaliException e) {
2575       {
2576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2577       };
2578     } catch (...) {
2579       {
2580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2581       };
2582     }
2583   }
2584   jresult = (void *)result;
2585   return jresult;
2586 }
2587
2588
2589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2590   floatp *arg1 = (floatp *) 0 ;
2591
2592   arg1 = (floatp *)jarg1;
2593   {
2594     try {
2595       delete_floatp(arg1);
2596     } catch (std::out_of_range& e) {
2597       {
2598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2599       };
2600     } catch (std::exception& e) {
2601       {
2602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2603       };
2604     } catch (Dali::DaliException e) {
2605       {
2606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2607       };
2608     } catch (...) {
2609       {
2610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2611       };
2612     }
2613   }
2614
2615 }
2616
2617
2618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2619   floatp *arg1 = (floatp *) 0 ;
2620   float arg2 ;
2621
2622   arg1 = (floatp *)jarg1;
2623   arg2 = (float)jarg2;
2624   {
2625     try {
2626       floatp_assign(arg1,arg2);
2627     } catch (std::out_of_range& e) {
2628       {
2629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2630       };
2631     } catch (std::exception& e) {
2632       {
2633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2634       };
2635     } catch (Dali::DaliException e) {
2636       {
2637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2638       };
2639     } catch (...) {
2640       {
2641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2642       };
2643     }
2644   }
2645
2646 }
2647
2648
2649 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2650   float jresult ;
2651   floatp *arg1 = (floatp *) 0 ;
2652   float result;
2653
2654   arg1 = (floatp *)jarg1;
2655   {
2656     try {
2657       result = (float)floatp_value(arg1);
2658     } catch (std::out_of_range& e) {
2659       {
2660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2661       };
2662     } catch (std::exception& e) {
2663       {
2664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2665       };
2666     } catch (DaliException e) {
2667       {
2668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2669       };
2670     } catch (...) {
2671       {
2672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2673       };
2674     }
2675   }
2676   jresult = result;
2677   return jresult;
2678 }
2679
2680
2681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2682   void * jresult ;
2683   floatp *arg1 = (floatp *) 0 ;
2684   float *result = 0 ;
2685
2686   arg1 = (floatp *)jarg1;
2687   {
2688     try {
2689       result = (float *)floatp_cast(arg1);
2690     } catch (std::out_of_range& e) {
2691       {
2692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2693       };
2694     } catch (std::exception& e) {
2695       {
2696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2697       };
2698     } catch (Dali::DaliException e) {
2699       {
2700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2701       };
2702     } catch (...) {
2703       {
2704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2705       };
2706     }
2707   }
2708
2709   jresult = (void *)result;
2710   return jresult;
2711 }
2712
2713
2714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2715   void * jresult ;
2716   float *arg1 = (float *) 0 ;
2717   floatp *result = 0 ;
2718
2719   arg1 = (float *)jarg1;
2720   {
2721     try {
2722       result = (floatp *)floatp_frompointer(arg1);
2723     } catch (std::out_of_range& e) {
2724       {
2725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2726       };
2727     } catch (std::exception& e) {
2728       {
2729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2730       };
2731     } catch (Dali::DaliException e) {
2732       {
2733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2734       };
2735     } catch (...) {
2736       {
2737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2738       };
2739     }
2740   }
2741
2742   jresult = (void *)result;
2743   return jresult;
2744 }
2745
2746
2747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2748   void * jresult ;
2749   intp *result = 0 ;
2750
2751   {
2752     try {
2753       result = (intp *)new_intp();
2754     } catch (std::out_of_range& e) {
2755       {
2756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2757       };
2758     } catch (std::exception& e) {
2759       {
2760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2761       };
2762     } catch (Dali::DaliException e) {
2763       {
2764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2765       };
2766     } catch (...) {
2767       {
2768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2769       };
2770     }
2771   }
2772
2773   jresult = (void *)result;
2774   return jresult;
2775 }
2776
2777
2778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2779   intp *arg1 = (intp *) 0 ;
2780
2781   arg1 = (intp *)jarg1;
2782   {
2783     try {
2784       delete_intp(arg1);
2785     } catch (std::out_of_range& e) {
2786       {
2787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2788       };
2789     } catch (std::exception& e) {
2790       {
2791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2792       };
2793     } catch (Dali::DaliException e) {
2794       {
2795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2796       };
2797     } catch (...) {
2798       {
2799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2800       };
2801     }
2802   }
2803
2804 }
2805
2806
2807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2808   intp *arg1 = (intp *) 0 ;
2809   int arg2 ;
2810
2811   arg1 = (intp *)jarg1;
2812   arg2 = (int)jarg2;
2813   {
2814     try {
2815       intp_assign(arg1,arg2);
2816     } catch (std::out_of_range& e) {
2817       {
2818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2819       };
2820     } catch (std::exception& e) {
2821       {
2822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2823       };
2824     } catch (Dali::DaliException e) {
2825       {
2826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2827       };
2828     } catch (...) {
2829       {
2830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2831       };
2832     }
2833   }
2834
2835 }
2836
2837
2838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2839   int jresult ;
2840   intp *arg1 = (intp *) 0 ;
2841   int result;
2842
2843   arg1 = (intp *)jarg1;
2844   {
2845     try {
2846       result = (int)intp_value(arg1);
2847     } catch (std::out_of_range& e) {
2848       {
2849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2850       };
2851     } catch (std::exception& e) {
2852       {
2853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2854       };
2855     } catch (Dali::DaliException e) {
2856       {
2857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2858       };
2859     } catch (...) {
2860       {
2861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2862       };
2863     }
2864   }
2865
2866   jresult = result;
2867   return jresult;
2868 }
2869
2870
2871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2872   void * jresult ;
2873   intp *arg1 = (intp *) 0 ;
2874   int *result = 0 ;
2875
2876   arg1 = (intp *)jarg1;
2877   {
2878     try {
2879       result = (int *)intp_cast(arg1);
2880     } catch (std::out_of_range& e) {
2881       {
2882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2883       };
2884     } catch (std::exception& e) {
2885       {
2886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2887       };
2888     } catch (Dali::DaliException e) {
2889       {
2890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2891       };
2892     } catch (...) {
2893       {
2894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2895       };
2896     }
2897   }
2898
2899   jresult = (void *)result;
2900   return jresult;
2901 }
2902
2903
2904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2905   void * jresult ;
2906   int *arg1 = (int *) 0 ;
2907   intp *result = 0 ;
2908
2909   arg1 = (int *)jarg1;
2910   {
2911     try {
2912       result = (intp *)intp_frompointer(arg1);
2913     } catch (std::out_of_range& e) {
2914       {
2915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2916       };
2917     } catch (std::exception& e) {
2918       {
2919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2920       };
2921     } catch (Dali::DaliException e) {
2922       {
2923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2924       };
2925     } catch (...) {
2926       {
2927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2928       };
2929     }
2930   }
2931
2932   jresult = (void *)result;
2933   return jresult;
2934 }
2935
2936
2937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2938   void * jresult ;
2939   doublep *result = 0 ;
2940
2941   {
2942     try {
2943       result = (doublep *)new_doublep();
2944     } catch (std::out_of_range& e) {
2945       {
2946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2947       };
2948     } catch (std::exception& e) {
2949       {
2950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2951       };
2952     } catch (Dali::DaliException e) {
2953       {
2954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2955       };
2956     } catch (...) {
2957       {
2958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2959       };
2960     }
2961   }
2962
2963   jresult = (void *)result;
2964   return jresult;
2965 }
2966
2967
2968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2969   doublep *arg1 = (doublep *) 0 ;
2970
2971   arg1 = (doublep *)jarg1;
2972   {
2973     try {
2974       delete_doublep(arg1);
2975     } catch (std::out_of_range& e) {
2976       {
2977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2978       };
2979     } catch (std::exception& e) {
2980       {
2981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2982       };
2983     } catch (Dali::DaliException e) {
2984       {
2985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2986       };
2987     } catch (...) {
2988       {
2989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2990       };
2991     }
2992   }
2993
2994 }
2995
2996
2997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2998   doublep *arg1 = (doublep *) 0 ;
2999   double arg2 ;
3000
3001   arg1 = (doublep *)jarg1;
3002   arg2 = (double)jarg2;
3003   {
3004     try {
3005       doublep_assign(arg1,arg2);
3006     } catch (std::out_of_range& e) {
3007       {
3008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3009       };
3010     } catch (std::exception& e) {
3011       {
3012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3013       };
3014     } catch (Dali::DaliException e) {
3015       {
3016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3017       };
3018     } catch (...) {
3019       {
3020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3021       };
3022     }
3023   }
3024
3025 }
3026
3027
3028 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3029   double jresult ;
3030   doublep *arg1 = (doublep *) 0 ;
3031   double result;
3032
3033   arg1 = (doublep *)jarg1;
3034   {
3035     try {
3036       result = (double)doublep_value(arg1);
3037     } catch (std::out_of_range& e) {
3038       {
3039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3040       };
3041     } catch (std::exception& e) {
3042       {
3043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3044       };
3045     } catch (Dali::DaliException e) {
3046       {
3047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3048       };
3049     } catch (...) {
3050       {
3051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3052       };
3053     }
3054   }
3055
3056   jresult = result;
3057   return jresult;
3058 }
3059
3060
3061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3062   void * jresult ;
3063   doublep *arg1 = (doublep *) 0 ;
3064   double *result = 0 ;
3065
3066   arg1 = (doublep *)jarg1;
3067   {
3068     try {
3069       result = (double *)doublep_cast(arg1);
3070     } catch (std::out_of_range& e) {
3071       {
3072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3073       };
3074     } catch (std::exception& e) {
3075       {
3076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3077       };
3078     } catch (Dali::DaliException e) {
3079       {
3080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3081       };
3082     } catch (...) {
3083       {
3084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3085       };
3086     }
3087   }
3088
3089   jresult = (void *)result;
3090   return jresult;
3091 }
3092
3093
3094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3095   void * jresult ;
3096   double *arg1 = (double *) 0 ;
3097   doublep *result = 0 ;
3098
3099   arg1 = (double *)jarg1;
3100   {
3101     try {
3102       result = (doublep *)doublep_frompointer(arg1);
3103     } catch (std::out_of_range& e) {
3104       {
3105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3106       };
3107     } catch (std::exception& e) {
3108       {
3109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3110       };
3111     } catch (Dali::DaliException e) {
3112       {
3113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3114       };
3115     } catch (...) {
3116       {
3117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3118       };
3119     }
3120   }
3121
3122   jresult = (void *)result;
3123   return jresult;
3124 }
3125
3126
3127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3128   void * jresult ;
3129   uintp *result = 0 ;
3130
3131   {
3132     try {
3133       result = (uintp *)new_uintp();
3134     } catch (std::out_of_range& e) {
3135       {
3136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3137       };
3138     } catch (std::exception& e) {
3139       {
3140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3141       };
3142     } catch (Dali::DaliException e) {
3143       {
3144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3145       };
3146     } catch (...) {
3147       {
3148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3149       };
3150     }
3151   }
3152
3153   jresult = (void *)result;
3154   return jresult;
3155 }
3156
3157
3158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3159   uintp *arg1 = (uintp *) 0 ;
3160
3161   arg1 = (uintp *)jarg1;
3162   {
3163     try {
3164       delete_uintp(arg1);
3165     } catch (std::out_of_range& e) {
3166       {
3167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3168       };
3169     } catch (std::exception& e) {
3170       {
3171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3172       };
3173     } catch (Dali::DaliException e) {
3174       {
3175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3176       };
3177     } catch (...) {
3178       {
3179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3180       };
3181     }
3182   }
3183
3184 }
3185
3186
3187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3188   uintp *arg1 = (uintp *) 0 ;
3189   unsigned int arg2 ;
3190
3191   arg1 = (uintp *)jarg1;
3192   arg2 = (unsigned int)jarg2;
3193   {
3194     try {
3195       uintp_assign(arg1,arg2);
3196     } catch (std::out_of_range& e) {
3197       {
3198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3199       };
3200     } catch (std::exception& e) {
3201       {
3202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3203       };
3204     } catch (Dali::DaliException e) {
3205       {
3206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3207       };
3208     } catch (...) {
3209       {
3210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3211       };
3212     }
3213   }
3214
3215 }
3216
3217
3218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3219   unsigned int jresult ;
3220   uintp *arg1 = (uintp *) 0 ;
3221   unsigned int result;
3222
3223   arg1 = (uintp *)jarg1;
3224   {
3225     try {
3226       result = (unsigned int)uintp_value(arg1);
3227     } catch (std::out_of_range& e) {
3228       {
3229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3230       };
3231     } catch (std::exception& e) {
3232       {
3233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3234       };
3235     } catch (Dali::DaliException e) {
3236       {
3237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3238       };
3239     } catch (...) {
3240       {
3241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3242       };
3243     }
3244   }
3245
3246   jresult = result;
3247   return jresult;
3248 }
3249
3250
3251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3252   void * jresult ;
3253   uintp *arg1 = (uintp *) 0 ;
3254   unsigned int *result = 0 ;
3255
3256   arg1 = (uintp *)jarg1;
3257   {
3258     try {
3259       result = (unsigned int *)uintp_cast(arg1);
3260     } catch (std::out_of_range& e) {
3261       {
3262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3263       };
3264     } catch (std::exception& e) {
3265       {
3266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3267       };
3268     } catch (Dali::DaliException e) {
3269       {
3270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3271       };
3272     } catch (...) {
3273       {
3274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3275       };
3276     }
3277   }
3278
3279   jresult = (void *)result;
3280   return jresult;
3281 }
3282
3283
3284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3285   void * jresult ;
3286   unsigned int *arg1 = (unsigned int *) 0 ;
3287   uintp *result = 0 ;
3288
3289   arg1 = (unsigned int *)jarg1;
3290   {
3291     try {
3292       result = (uintp *)uintp_frompointer(arg1);
3293     } catch (std::out_of_range& e) {
3294       {
3295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3296       };
3297     } catch (std::exception& e) {
3298       {
3299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3300       };
3301     } catch (Dali::DaliException e) {
3302       {
3303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3304       };
3305     } catch (...) {
3306       {
3307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3308       };
3309     }
3310   }
3311
3312   jresult = (void *)result;
3313   return jresult;
3314 }
3315
3316
3317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3318   void * jresult ;
3319   ushortp *result = 0 ;
3320
3321   {
3322     try {
3323       result = (ushortp *)new_ushortp();
3324     } catch (std::out_of_range& e) {
3325       {
3326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3327       };
3328     } catch (std::exception& e) {
3329       {
3330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3331       };
3332     } catch (Dali::DaliException e) {
3333       {
3334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3335       };
3336     } catch (...) {
3337       {
3338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3339       };
3340     }
3341   }
3342
3343   jresult = (void *)result;
3344   return jresult;
3345 }
3346
3347
3348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3349   ushortp *arg1 = (ushortp *) 0 ;
3350
3351   arg1 = (ushortp *)jarg1;
3352   {
3353     try {
3354       delete_ushortp(arg1);
3355     } catch (std::out_of_range& e) {
3356       {
3357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3358       };
3359     } catch (std::exception& e) {
3360       {
3361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3362       };
3363     } catch (Dali::DaliException e) {
3364       {
3365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3366       };
3367     } catch (...) {
3368       {
3369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3370       };
3371     }
3372   }
3373
3374 }
3375
3376
3377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3378   ushortp *arg1 = (ushortp *) 0 ;
3379   unsigned short arg2 ;
3380
3381   arg1 = (ushortp *)jarg1;
3382   arg2 = (unsigned short)jarg2;
3383   {
3384     try {
3385       ushortp_assign(arg1,arg2);
3386     } catch (std::out_of_range& e) {
3387       {
3388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3389       };
3390     } catch (std::exception& e) {
3391       {
3392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3393       };
3394     } catch (Dali::DaliException e) {
3395       {
3396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3397       };
3398     } catch (...) {
3399       {
3400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3401       };
3402     }
3403   }
3404
3405 }
3406
3407
3408 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3409   unsigned short jresult ;
3410   ushortp *arg1 = (ushortp *) 0 ;
3411   unsigned short result;
3412
3413   arg1 = (ushortp *)jarg1;
3414   {
3415     try {
3416       result = (unsigned short)ushortp_value(arg1);
3417     } catch (std::out_of_range& e) {
3418       {
3419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3420       };
3421     } catch (std::exception& e) {
3422       {
3423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3424       };
3425     } catch (Dali::DaliException e) {
3426       {
3427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3428       };
3429     } catch (...) {
3430       {
3431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3432       };
3433     }
3434   }
3435
3436   jresult = result;
3437   return jresult;
3438 }
3439
3440
3441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3442   void * jresult ;
3443   ushortp *arg1 = (ushortp *) 0 ;
3444   unsigned short *result = 0 ;
3445
3446   arg1 = (ushortp *)jarg1;
3447   {
3448     try {
3449       result = (unsigned short *)ushortp_cast(arg1);
3450     } catch (std::out_of_range& e) {
3451       {
3452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3453       };
3454     } catch (std::exception& e) {
3455       {
3456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3457       };
3458     } catch (Dali::DaliException e) {
3459       {
3460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3461       };
3462     } catch (...) {
3463       {
3464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3465       };
3466     }
3467   }
3468
3469   jresult = (void *)result;
3470   return jresult;
3471 }
3472
3473
3474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3475   void * jresult ;
3476   unsigned short *arg1 = (unsigned short *) 0 ;
3477   ushortp *result = 0 ;
3478
3479   arg1 = (unsigned short *)jarg1;
3480   {
3481     try {
3482       result = (ushortp *)ushortp_frompointer(arg1);
3483     } catch (std::out_of_range& e) {
3484       {
3485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3486       };
3487     } catch (std::exception& e) {
3488       {
3489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3490       };
3491     } catch (Dali::DaliException e) {
3492       {
3493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3494       };
3495     } catch (...) {
3496       {
3497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3498       };
3499     }
3500   }
3501
3502   jresult = (void *)result;
3503   return jresult;
3504 }
3505
3506
3507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3508   unsigned int jresult ;
3509   int arg1 ;
3510   unsigned int result;
3511
3512   arg1 = (int)jarg1;
3513   {
3514     try {
3515       result = (unsigned int)int_to_uint(arg1);
3516     } catch (std::out_of_range& e) {
3517       {
3518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3519       };
3520     } catch (std::exception& e) {
3521       {
3522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3523       };
3524     } catch (Dali::DaliException e) {
3525       {
3526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3527       };
3528     } catch (...) {
3529       {
3530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3531       };
3532     }
3533   }
3534
3535   jresult = result;
3536   return jresult;
3537 }
3538
3539
3540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3541   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3542
3543   arg1 = (Dali::RefObject *)jarg1;
3544   {
3545     try {
3546       (arg1)->Reference();
3547     } catch (std::out_of_range& e) {
3548       {
3549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3550       };
3551     } catch (std::exception& e) {
3552       {
3553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3554       };
3555     } catch (Dali::DaliException e) {
3556       {
3557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3558       };
3559     } catch (...) {
3560       {
3561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3562       };
3563     }
3564   }
3565
3566 }
3567
3568
3569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3570   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3571
3572   arg1 = (Dali::RefObject *)jarg1;
3573   {
3574     try {
3575       (arg1)->Unreference();
3576     } catch (std::out_of_range& e) {
3577       {
3578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3579       };
3580     } catch (std::exception& e) {
3581       {
3582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3583       };
3584     } catch (Dali::DaliException e) {
3585       {
3586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3587       };
3588     } catch (...) {
3589       {
3590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3591       };
3592     }
3593   }
3594
3595 }
3596
3597
3598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3599   int jresult ;
3600   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3601   int result;
3602
3603   arg1 = (Dali::RefObject *)jarg1;
3604   {
3605     try {
3606       result = (int)(arg1)->ReferenceCount();
3607     } catch (std::out_of_range& e) {
3608       {
3609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3610       };
3611     } catch (std::exception& e) {
3612       {
3613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3614       };
3615     } catch (Dali::DaliException e) {
3616       {
3617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3618       };
3619     } catch (...) {
3620       {
3621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3622       };
3623     }
3624   }
3625
3626   jresult = result;
3627   return jresult;
3628 }
3629
3630
3631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3632   void * jresult ;
3633   Dali::Any *result = 0 ;
3634
3635   {
3636     try {
3637       result = (Dali::Any *)new Dali::Any();
3638     } catch (std::out_of_range& e) {
3639       {
3640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3641       };
3642     } catch (std::exception& e) {
3643       {
3644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3645       };
3646     } catch (Dali::DaliException e) {
3647       {
3648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3649       };
3650     } catch (...) {
3651       {
3652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3653       };
3654     }
3655   }
3656
3657   jresult = (void *)result;
3658   return jresult;
3659 }
3660
3661
3662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3663   Dali::Any *arg1 = (Dali::Any *) 0 ;
3664
3665   arg1 = (Dali::Any *)jarg1;
3666   {
3667     try {
3668       delete arg1;
3669     } catch (std::out_of_range& e) {
3670       {
3671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3672       };
3673     } catch (std::exception& e) {
3674       {
3675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3676       };
3677     } catch (Dali::DaliException e) {
3678       {
3679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3680       };
3681     } catch (...) {
3682       {
3683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3684       };
3685     }
3686   }
3687
3688 }
3689
3690
3691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3692   char *arg1 = (char *) 0 ;
3693
3694   arg1 = (char *)jarg1;
3695   {
3696     try {
3697       Dali::Any::AssertAlways((char const *)arg1);
3698     } catch (std::out_of_range& e) {
3699       {
3700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3701       };
3702     } catch (std::exception& e) {
3703       {
3704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3705       };
3706     } catch (Dali::DaliException e) {
3707       {
3708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3709       };
3710     } catch (...) {
3711       {
3712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3713       };
3714     }
3715   }
3716
3717 }
3718
3719
3720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3721   void * jresult ;
3722   Dali::Any *arg1 = 0 ;
3723   Dali::Any *result = 0 ;
3724
3725   arg1 = (Dali::Any *)jarg1;
3726   if (!arg1) {
3727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3728     return 0;
3729   }
3730   {
3731     try {
3732       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3733     } catch (std::out_of_range& e) {
3734       {
3735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3736       };
3737     } catch (std::exception& e) {
3738       {
3739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3740       };
3741     } catch (Dali::DaliException e) {
3742       {
3743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3744       };
3745     } catch (...) {
3746       {
3747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3748       };
3749     }
3750   }
3751
3752   jresult = (void *)result;
3753   return jresult;
3754 }
3755
3756
3757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3758   void * jresult ;
3759   Dali::Any *arg1 = (Dali::Any *) 0 ;
3760   Dali::Any *arg2 = 0 ;
3761   Dali::Any *result = 0 ;
3762
3763   arg1 = (Dali::Any *)jarg1;
3764   arg2 = (Dali::Any *)jarg2;
3765   if (!arg2) {
3766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3767     return 0;
3768   }
3769   {
3770     try {
3771       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3772     } catch (std::out_of_range& e) {
3773       {
3774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3775       };
3776     } catch (std::exception& e) {
3777       {
3778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3779       };
3780     } catch (Dali::DaliException e) {
3781       {
3782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3783       };
3784     } catch (...) {
3785       {
3786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3787       };
3788     }
3789   }
3790
3791   jresult = (void *)result;
3792   return jresult;
3793 }
3794
3795
3796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3797   void * jresult ;
3798   Dali::Any *arg1 = (Dali::Any *) 0 ;
3799   std::type_info *result = 0 ;
3800
3801   arg1 = (Dali::Any *)jarg1;
3802   {
3803     try {
3804       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3805     } catch (std::out_of_range& e) {
3806       {
3807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3808       };
3809     } catch (std::exception& e) {
3810       {
3811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3812       };
3813     } catch (Dali::DaliException e) {
3814       {
3815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3816       };
3817     } catch (...) {
3818       {
3819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3820       };
3821     }
3822   }
3823
3824   jresult = (void *)result;
3825   return jresult;
3826 }
3827
3828
3829 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3830   unsigned int jresult ;
3831   Dali::Any *arg1 = (Dali::Any *) 0 ;
3832   bool result;
3833
3834   arg1 = (Dali::Any *)jarg1;
3835   {
3836     try {
3837       result = (bool)((Dali::Any const *)arg1)->Empty();
3838     } catch (std::out_of_range& e) {
3839       {
3840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3841       };
3842     } catch (std::exception& e) {
3843       {
3844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3845       };
3846     } catch (Dali::DaliException e) {
3847       {
3848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3849       };
3850     } catch (...) {
3851       {
3852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3853       };
3854     }
3855   }
3856
3857   jresult = result;
3858   return jresult;
3859 }
3860
3861
3862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3863   void * jresult ;
3864   std::type_info *arg1 = 0 ;
3865   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3866   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3867   Dali::Any::AnyContainerBase *result = 0 ;
3868
3869   arg1 = (std::type_info *)jarg1;
3870   if (!arg1) {
3871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3872     return 0;
3873   }
3874   arg2 = (Dali::Any::CloneFunc)jarg2;
3875   arg3 = (Dali::Any::DeleteFunc)jarg3;
3876   {
3877     try {
3878       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3879     } catch (std::out_of_range& e) {
3880       {
3881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3882       };
3883     } catch (std::exception& e) {
3884       {
3885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3886       };
3887     } catch (Dali::DaliException e) {
3888       {
3889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3890       };
3891     } catch (...) {
3892       {
3893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3894       };
3895     }
3896   }
3897
3898   jresult = (void *)result;
3899   return jresult;
3900 }
3901
3902
3903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3904   void * jresult ;
3905   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3906   std::type_info *result = 0 ;
3907
3908   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3909   {
3910     try {
3911       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3912     } catch (std::out_of_range& e) {
3913       {
3914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3915       };
3916     } catch (std::exception& e) {
3917       {
3918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3919       };
3920     } catch (Dali::DaliException e) {
3921       {
3922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3923       };
3924     } catch (...) {
3925       {
3926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3927       };
3928     }
3929   }
3930
3931   jresult = (void *)result;
3932   return jresult;
3933 }
3934
3935
3936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3937   void * jresult ;
3938   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3939   ::std::type_info *result = 0 ;
3940
3941   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3942   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3943   jresult = (void *)result;
3944   return jresult;
3945 }
3946
3947
3948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3949   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3950   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3951
3952   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3953   arg2 = (Dali::Any::CloneFunc)jarg2;
3954   if (arg1) (arg1)->mCloneFunc = arg2;
3955 }
3956
3957
3958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3959   void * jresult ;
3960   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3961   Dali::Any::CloneFunc result;
3962
3963   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3964   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3965   jresult = (void *)result;
3966   return jresult;
3967 }
3968
3969
3970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3971   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3972   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3973
3974   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3975   arg2 = (Dali::Any::DeleteFunc)jarg2;
3976   if (arg1) (arg1)->mDeleteFunc = arg2;
3977 }
3978
3979
3980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3981   void * jresult ;
3982   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3983   Dali::Any::DeleteFunc result;
3984
3985   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3986   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3987   jresult = (void *)result;
3988   return jresult;
3989 }
3990
3991
3992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3993   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3994
3995   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3996   {
3997     try {
3998       delete arg1;
3999     } catch (std::out_of_range& e) {
4000       {
4001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4002       };
4003     } catch (std::exception& e) {
4004       {
4005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4006       };
4007     } catch (Dali::DaliException e) {
4008       {
4009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4010       };
4011     } catch (...) {
4012       {
4013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4014       };
4015     }
4016   }
4017
4018 }
4019
4020
4021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4022   Dali::Any *arg1 = (Dali::Any *) 0 ;
4023   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4024
4025   arg1 = (Dali::Any *)jarg1;
4026   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4027   if (arg1) (arg1)->mContainer = arg2;
4028 }
4029
4030
4031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4032   void * jresult ;
4033   Dali::Any *arg1 = (Dali::Any *) 0 ;
4034   Dali::Any::AnyContainerBase *result = 0 ;
4035
4036   arg1 = (Dali::Any *)jarg1;
4037   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4038   jresult = (void *)result;
4039   return jresult;
4040 }
4041
4042
4043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4044   char *arg1 = (char *) 0 ;
4045   char *arg2 = (char *) 0 ;
4046
4047   arg1 = (char *)jarg1;
4048   arg2 = (char *)jarg2;
4049   {
4050     try {
4051       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4052     } catch (std::out_of_range& e) {
4053       {
4054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4055       };
4056     } catch (std::exception& e) {
4057       {
4058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4059       };
4060     } catch (Dali::DaliException e) {
4061       {
4062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4063       };
4064     } catch (...) {
4065       {
4066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4067       };
4068     }
4069   }
4070
4071 }
4072
4073
4074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4075   void * jresult ;
4076   char *arg1 = (char *) 0 ;
4077   char *arg2 = (char *) 0 ;
4078   Dali::DaliException *result = 0 ;
4079
4080   arg1 = (char *)jarg1;
4081   arg2 = (char *)jarg2;
4082   {
4083     try {
4084       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4085     } catch (std::out_of_range& e) {
4086       {
4087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4088       };
4089     } catch (std::exception& e) {
4090       {
4091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4092       };
4093     } catch (Dali::DaliException e) {
4094       {
4095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4096       };
4097     } catch (...) {
4098       {
4099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4100       };
4101     }
4102   }
4103
4104   jresult = (void *)result;
4105   return jresult;
4106 }
4107
4108
4109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4110   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4111   std::string arg2 = std::string(jarg2);
4112
4113   arg1 = (Dali::DaliException *)jarg1;
4114   {
4115     if (!arg2.empty()) {
4116       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4117     } else {
4118       arg1->location = 0;
4119     }
4120   }
4121 }
4122
4123 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4124   char * jresult ;
4125   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4126   char *result = 0 ;
4127
4128   arg1 = (Dali::DaliException *)jarg1;
4129   result = (char *) ((arg1)->location);
4130   jresult = SWIG_csharp_string_callback((const char *)result);
4131   return jresult;
4132 }
4133
4134
4135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4136   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4137   std::string arg2 = std::string(jarg2);
4138
4139   arg1 = (Dali::DaliException *)jarg1;
4140   {
4141     if (!arg2.empty()) {
4142       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4143     } else {
4144       arg1->condition = 0;
4145     }
4146   }
4147 }
4148
4149
4150 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4151   char * jresult ;
4152   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4153   char *result = 0 ;
4154
4155   arg1 = (Dali::DaliException *)jarg1;
4156   result = (char *) ((arg1)->condition);
4157   jresult = SWIG_csharp_string_callback((const char *)result);
4158   return jresult;
4159 }
4160
4161
4162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4163   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4164
4165   arg1 = (Dali::DaliException *)jarg1;
4166   {
4167     try {
4168       delete arg1;
4169     } catch (std::out_of_range& e) {
4170       {
4171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4172       };
4173     } catch (std::exception& e) {
4174       {
4175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4176       };
4177     } catch (Dali::DaliException e) {
4178       {
4179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4180       };
4181     } catch (...) {
4182       {
4183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4184       };
4185     }
4186   }
4187
4188 }
4189
4190
4191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4192   void * jresult ;
4193   Dali::Vector2 *result = 0 ;
4194
4195   {
4196     try {
4197       result = (Dali::Vector2 *)new Dali::Vector2();
4198     } catch (std::out_of_range& e) {
4199       {
4200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4201       };
4202     } catch (std::exception& e) {
4203       {
4204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4205       };
4206     } catch (Dali::DaliException e) {
4207       {
4208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4209       };
4210     } catch (...) {
4211       {
4212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4213       };
4214     }
4215   }
4216
4217   jresult = (void *)result;
4218   return jresult;
4219 }
4220
4221
4222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4223   void * jresult ;
4224   float arg1 ;
4225   float arg2 ;
4226   Dali::Vector2 *result = 0 ;
4227
4228   arg1 = (float)jarg1;
4229   arg2 = (float)jarg2;
4230   {
4231     try {
4232       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4233     } catch (std::out_of_range& e) {
4234       {
4235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4236       };
4237     } catch (std::exception& e) {
4238       {
4239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4240       };
4241     } catch (Dali::DaliException e) {
4242       {
4243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4244       };
4245     } catch (...) {
4246       {
4247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4248       };
4249     }
4250   }
4251
4252   jresult = (void *)result;
4253   return jresult;
4254 }
4255
4256
4257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4258   void * jresult ;
4259   float *arg1 = (float *) 0 ;
4260   Dali::Vector2 *result = 0 ;
4261
4262   arg1 = jarg1;
4263   {
4264     try {
4265       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4266     } catch (std::out_of_range& e) {
4267       {
4268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4269       };
4270     } catch (std::exception& e) {
4271       {
4272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4273       };
4274     } catch (Dali::DaliException e) {
4275       {
4276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4277       };
4278     } catch (...) {
4279       {
4280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4281       };
4282     }
4283   }
4284
4285   jresult = (void *)result;
4286
4287
4288   return jresult;
4289 }
4290
4291
4292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4293   void * jresult ;
4294   Dali::Vector3 *arg1 = 0 ;
4295   Dali::Vector2 *result = 0 ;
4296
4297   arg1 = (Dali::Vector3 *)jarg1;
4298   if (!arg1) {
4299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4300     return 0;
4301   }
4302   {
4303     try {
4304       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4305     } catch (std::out_of_range& e) {
4306       {
4307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4308       };
4309     } catch (std::exception& e) {
4310       {
4311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4312       };
4313     } catch (Dali::DaliException e) {
4314       {
4315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4316       };
4317     } catch (...) {
4318       {
4319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4320       };
4321     }
4322   }
4323
4324   jresult = (void *)result;
4325   return jresult;
4326 }
4327
4328
4329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4330   void * jresult ;
4331   Dali::Vector4 *arg1 = 0 ;
4332   Dali::Vector2 *result = 0 ;
4333
4334   arg1 = (Dali::Vector4 *)jarg1;
4335   if (!arg1) {
4336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4337     return 0;
4338   }
4339   {
4340     try {
4341       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4342     } catch (std::out_of_range& e) {
4343       {
4344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4345       };
4346     } catch (std::exception& e) {
4347       {
4348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4349       };
4350     } catch (Dali::DaliException e) {
4351       {
4352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4353       };
4354     } catch (...) {
4355       {
4356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4357       };
4358     }
4359   }
4360
4361   jresult = (void *)result;
4362   return jresult;
4363 }
4364
4365
4366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4367   void * jresult ;
4368   Dali::Vector2 *result = 0 ;
4369
4370   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4371   jresult = (void *)result;
4372   return jresult;
4373 }
4374
4375
4376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4377   void * jresult ;
4378   Dali::Vector2 *result = 0 ;
4379
4380   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4381   jresult = (void *)result;
4382   return jresult;
4383 }
4384
4385
4386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4387   void * jresult ;
4388   Dali::Vector2 *result = 0 ;
4389
4390   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4391   jresult = (void *)result;
4392   return jresult;
4393 }
4394
4395
4396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4397   void * jresult ;
4398   Dali::Vector2 *result = 0 ;
4399
4400   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4401   jresult = (void *)result;
4402   return jresult;
4403 }
4404
4405
4406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4407   void * jresult ;
4408   Dali::Vector2 *result = 0 ;
4409
4410   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4411   jresult = (void *)result;
4412   return jresult;
4413 }
4414
4415
4416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4417   void * jresult ;
4418   Dali::Vector2 *result = 0 ;
4419
4420   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4421   jresult = (void *)result;
4422   return jresult;
4423 }
4424
4425
4426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4427   void * jresult ;
4428   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4429   float *arg2 = (float *) 0 ;
4430   Dali::Vector2 *result = 0 ;
4431
4432   arg1 = (Dali::Vector2 *)jarg1;
4433   arg2 = jarg2;
4434   {
4435     try {
4436       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4437     } catch (std::out_of_range& e) {
4438       {
4439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4440       };
4441     } catch (std::exception& e) {
4442       {
4443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4444       };
4445     } catch (Dali::DaliException e) {
4446       {
4447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4448       };
4449     } catch (...) {
4450       {
4451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4452       };
4453     }
4454   }
4455
4456   jresult = (void *)result;
4457
4458
4459   return jresult;
4460 }
4461
4462
4463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4464   void * jresult ;
4465   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4466   Dali::Vector3 *arg2 = 0 ;
4467   Dali::Vector2 *result = 0 ;
4468
4469   arg1 = (Dali::Vector2 *)jarg1;
4470   arg2 = (Dali::Vector3 *)jarg2;
4471   if (!arg2) {
4472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4473     return 0;
4474   }
4475   {
4476     try {
4477       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4478     } catch (std::out_of_range& e) {
4479       {
4480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4481       };
4482     } catch (std::exception& e) {
4483       {
4484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4485       };
4486     } catch (Dali::DaliException e) {
4487       {
4488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4489       };
4490     } catch (...) {
4491       {
4492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4493       };
4494     }
4495   }
4496
4497   jresult = (void *)result;
4498   return jresult;
4499 }
4500
4501
4502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4503   void * jresult ;
4504   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4505   Dali::Vector4 *arg2 = 0 ;
4506   Dali::Vector2 *result = 0 ;
4507
4508   arg1 = (Dali::Vector2 *)jarg1;
4509   arg2 = (Dali::Vector4 *)jarg2;
4510   if (!arg2) {
4511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4512     return 0;
4513   }
4514   {
4515     try {
4516       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4517     } catch (std::out_of_range& e) {
4518       {
4519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4520       };
4521     } catch (std::exception& e) {
4522       {
4523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4524       };
4525     } catch (Dali::DaliException e) {
4526       {
4527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4528       };
4529     } catch (...) {
4530       {
4531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4532       };
4533     }
4534   }
4535
4536   jresult = (void *)result;
4537   return jresult;
4538 }
4539
4540
4541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4542   void * jresult ;
4543   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4544   Dali::Vector2 *arg2 = 0 ;
4545   Dali::Vector2 result;
4546
4547   arg1 = (Dali::Vector2 *)jarg1;
4548   arg2 = (Dali::Vector2 *)jarg2;
4549   if (!arg2) {
4550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4551     return 0;
4552   }
4553   {
4554     try {
4555       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4556     } catch (std::out_of_range& e) {
4557       {
4558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4559       };
4560     } catch (std::exception& e) {
4561       {
4562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4563       };
4564     } catch (Dali::DaliException e) {
4565       {
4566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4567       };
4568     } catch (...) {
4569       {
4570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4571       };
4572     }
4573   }
4574
4575   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4576   return jresult;
4577 }
4578
4579
4580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4581   void * jresult ;
4582   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4583   Dali::Vector2 *arg2 = 0 ;
4584   Dali::Vector2 *result = 0 ;
4585
4586   arg1 = (Dali::Vector2 *)jarg1;
4587   arg2 = (Dali::Vector2 *)jarg2;
4588   if (!arg2) {
4589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4590     return 0;
4591   }
4592   {
4593     try {
4594       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4595     } catch (std::out_of_range& e) {
4596       {
4597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4598       };
4599     } catch (std::exception& e) {
4600       {
4601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4602       };
4603     } catch (Dali::DaliException e) {
4604       {
4605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4606       };
4607     } catch (...) {
4608       {
4609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4610       };
4611     }
4612   }
4613
4614   jresult = (void *)result;
4615   return jresult;
4616 }
4617
4618
4619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4620   void * jresult ;
4621   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4622   Dali::Vector2 *arg2 = 0 ;
4623   Dali::Vector2 result;
4624
4625   arg1 = (Dali::Vector2 *)jarg1;
4626   arg2 = (Dali::Vector2 *)jarg2;
4627   if (!arg2) {
4628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4629     return 0;
4630   }
4631   {
4632     try {
4633       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4634     } catch (std::out_of_range& e) {
4635       {
4636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4637       };
4638     } catch (std::exception& e) {
4639       {
4640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4641       };
4642     } catch (Dali::DaliException e) {
4643       {
4644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4645       };
4646     } catch (...) {
4647       {
4648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4649       };
4650     }
4651   }
4652
4653   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4654   return jresult;
4655 }
4656
4657
4658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4659   void * jresult ;
4660   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4661   Dali::Vector2 *arg2 = 0 ;
4662   Dali::Vector2 *result = 0 ;
4663
4664   arg1 = (Dali::Vector2 *)jarg1;
4665   arg2 = (Dali::Vector2 *)jarg2;
4666   if (!arg2) {
4667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4668     return 0;
4669   }
4670   {
4671     try {
4672       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4673     } catch (std::out_of_range& e) {
4674       {
4675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4676       };
4677     } catch (std::exception& e) {
4678       {
4679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4680       };
4681     } catch (Dali::DaliException e) {
4682       {
4683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4684       };
4685     } catch (...) {
4686       {
4687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4688       };
4689     }
4690   }
4691
4692   jresult = (void *)result;
4693   return jresult;
4694 }
4695
4696
4697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4698   void * jresult ;
4699   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4700   Dali::Vector2 *arg2 = 0 ;
4701   Dali::Vector2 result;
4702
4703   arg1 = (Dali::Vector2 *)jarg1;
4704   arg2 = (Dali::Vector2 *)jarg2;
4705   if (!arg2) {
4706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4707     return 0;
4708   }
4709   {
4710     try {
4711       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4712     } catch (std::out_of_range& e) {
4713       {
4714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4715       };
4716     } catch (std::exception& e) {
4717       {
4718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4719       };
4720     } catch (Dali::DaliException e) {
4721       {
4722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4723       };
4724     } catch (...) {
4725       {
4726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4727       };
4728     }
4729   }
4730
4731   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4732   return jresult;
4733 }
4734
4735
4736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4737   void * jresult ;
4738   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4739   float arg2 ;
4740   Dali::Vector2 result;
4741
4742   arg1 = (Dali::Vector2 *)jarg1;
4743   arg2 = (float)jarg2;
4744   {
4745     try {
4746       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4747     } catch (std::out_of_range& e) {
4748       {
4749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4750       };
4751     } catch (std::exception& e) {
4752       {
4753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4754       };
4755     } catch (Dali::DaliException e) {
4756       {
4757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4758       };
4759     } catch (...) {
4760       {
4761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4762       };
4763     }
4764   }
4765
4766   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4767   return jresult;
4768 }
4769
4770
4771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4772   void * jresult ;
4773   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4774   Dali::Vector2 *arg2 = 0 ;
4775   Dali::Vector2 *result = 0 ;
4776
4777   arg1 = (Dali::Vector2 *)jarg1;
4778   arg2 = (Dali::Vector2 *)jarg2;
4779   if (!arg2) {
4780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4781     return 0;
4782   }
4783   {
4784     try {
4785       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4786     } catch (std::out_of_range& e) {
4787       {
4788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4789       };
4790     } catch (std::exception& e) {
4791       {
4792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4793       };
4794     } catch (Dali::DaliException e) {
4795       {
4796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4797       };
4798     } catch (...) {
4799       {
4800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4801       };
4802     }
4803   }
4804
4805   jresult = (void *)result;
4806   return jresult;
4807 }
4808
4809
4810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4811   void * jresult ;
4812   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4813   float arg2 ;
4814   Dali::Vector2 *result = 0 ;
4815
4816   arg1 = (Dali::Vector2 *)jarg1;
4817   arg2 = (float)jarg2;
4818   {
4819     try {
4820       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4821     } catch (std::out_of_range& e) {
4822       {
4823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4824       };
4825     } catch (std::exception& e) {
4826       {
4827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4828       };
4829     } catch (Dali::DaliException e) {
4830       {
4831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4832       };
4833     } catch (...) {
4834       {
4835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4836       };
4837     }
4838   }
4839
4840   jresult = (void *)result;
4841   return jresult;
4842 }
4843
4844
4845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4846   void * jresult ;
4847   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4848   Dali::Vector2 *arg2 = 0 ;
4849   Dali::Vector2 result;
4850
4851   arg1 = (Dali::Vector2 *)jarg1;
4852   arg2 = (Dali::Vector2 *)jarg2;
4853   if (!arg2) {
4854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4855     return 0;
4856   }
4857   {
4858     try {
4859       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4860     } catch (std::out_of_range& e) {
4861       {
4862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4863       };
4864     } catch (std::exception& e) {
4865       {
4866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4867       };
4868     } catch (Dali::DaliException e) {
4869       {
4870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4871       };
4872     } catch (...) {
4873       {
4874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4875       };
4876     }
4877   }
4878
4879   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4880   return jresult;
4881 }
4882
4883
4884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4885   void * jresult ;
4886   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4887   float arg2 ;
4888   Dali::Vector2 result;
4889
4890   arg1 = (Dali::Vector2 *)jarg1;
4891   arg2 = (float)jarg2;
4892   {
4893     try {
4894       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4895     } catch (std::out_of_range& e) {
4896       {
4897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4898       };
4899     } catch (std::exception& e) {
4900       {
4901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4902       };
4903     } catch (Dali::DaliException e) {
4904       {
4905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4906       };
4907     } catch (...) {
4908       {
4909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4910       };
4911     }
4912   }
4913
4914   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4915   return jresult;
4916 }
4917
4918
4919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4920   void * jresult ;
4921   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4922   Dali::Vector2 *arg2 = 0 ;
4923   Dali::Vector2 *result = 0 ;
4924
4925   arg1 = (Dali::Vector2 *)jarg1;
4926   arg2 = (Dali::Vector2 *)jarg2;
4927   if (!arg2) {
4928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4929     return 0;
4930   }
4931   {
4932     try {
4933       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4934     } catch (std::out_of_range& e) {
4935       {
4936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4937       };
4938     } catch (std::exception& e) {
4939       {
4940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4941       };
4942     } catch (Dali::DaliException e) {
4943       {
4944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4945       };
4946     } catch (...) {
4947       {
4948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4949       };
4950     }
4951   }
4952
4953   jresult = (void *)result;
4954   return jresult;
4955 }
4956
4957
4958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4959   void * jresult ;
4960   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4961   float arg2 ;
4962   Dali::Vector2 *result = 0 ;
4963
4964   arg1 = (Dali::Vector2 *)jarg1;
4965   arg2 = (float)jarg2;
4966   {
4967     try {
4968       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4969     } catch (std::out_of_range& e) {
4970       {
4971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4972       };
4973     } catch (std::exception& e) {
4974       {
4975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4976       };
4977     } catch (Dali::DaliException e) {
4978       {
4979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4980       };
4981     } catch (...) {
4982       {
4983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4984       };
4985     }
4986   }
4987
4988   jresult = (void *)result;
4989   return jresult;
4990 }
4991
4992
4993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4994   void * jresult ;
4995   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4996   Dali::Vector2 result;
4997
4998   arg1 = (Dali::Vector2 *)jarg1;
4999   {
5000     try {
5001       result = ((Dali::Vector2 const *)arg1)->operator -();
5002     } catch (std::out_of_range& e) {
5003       {
5004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5005       };
5006     } catch (std::exception& e) {
5007       {
5008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5009       };
5010     } catch (Dali::DaliException e) {
5011       {
5012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5013       };
5014     } catch (...) {
5015       {
5016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5017       };
5018     }
5019   }
5020
5021   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5022   return jresult;
5023 }
5024
5025
5026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5027   unsigned int jresult ;
5028   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5029   Dali::Vector2 *arg2 = 0 ;
5030   bool result;
5031
5032   arg1 = (Dali::Vector2 *)jarg1;
5033   arg2 = (Dali::Vector2 *)jarg2;
5034   if (!arg2) {
5035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5036     return 0;
5037   }
5038   {
5039     try {
5040       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5041     } catch (std::out_of_range& e) {
5042       {
5043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5044       };
5045     } catch (std::exception& e) {
5046       {
5047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5048       };
5049     } catch (Dali::DaliException e) {
5050       {
5051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5052       };
5053     } catch (...) {
5054       {
5055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5056       };
5057     }
5058   }
5059
5060   jresult = result;
5061   return jresult;
5062 }
5063
5064
5065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5066   unsigned int jresult ;
5067   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5068   Dali::Vector2 *arg2 = 0 ;
5069   bool result;
5070
5071   arg1 = (Dali::Vector2 *)jarg1;
5072   arg2 = (Dali::Vector2 *)jarg2;
5073   if (!arg2) {
5074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5075     return 0;
5076   }
5077   {
5078     try {
5079       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5080     } catch (std::out_of_range& e) {
5081       {
5082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5083       };
5084     } catch (std::exception& e) {
5085       {
5086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5087       };
5088     } catch (Dali::DaliException e) {
5089       {
5090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5091       };
5092     } catch (...) {
5093       {
5094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5095       };
5096     }
5097   }
5098
5099   jresult = result;
5100   return jresult;
5101 }
5102
5103
5104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5105   float jresult ;
5106   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5107   unsigned int arg2 ;
5108   float *result = 0 ;
5109
5110   arg1 = (Dali::Vector2 *)jarg1;
5111   arg2 = (unsigned int)jarg2;
5112   {
5113     try {
5114       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5115     } catch (std::out_of_range& e) {
5116       {
5117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5118       };
5119     } catch (std::exception& e) {
5120       {
5121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5122       };
5123     } catch (Dali::DaliException e) {
5124       {
5125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5126       };
5127     } catch (...) {
5128       {
5129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5130       };
5131     }
5132   }
5133
5134   jresult = *result;
5135   return jresult;
5136 }
5137
5138
5139 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5140   float jresult ;
5141   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5142   float result;
5143
5144   arg1 = (Dali::Vector2 *)jarg1;
5145   {
5146     try {
5147       result = (float)((Dali::Vector2 const *)arg1)->Length();
5148     } catch (std::out_of_range& e) {
5149       {
5150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5151       };
5152     } catch (std::exception& e) {
5153       {
5154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5155       };
5156     } catch (Dali::DaliException e) {
5157       {
5158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5159       };
5160     } catch (...) {
5161       {
5162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5163       };
5164     }
5165   }
5166
5167   jresult = result;
5168   return jresult;
5169 }
5170
5171
5172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5173   float jresult ;
5174   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5175   float result;
5176
5177   arg1 = (Dali::Vector2 *)jarg1;
5178   {
5179     try {
5180       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5181     } catch (std::out_of_range& e) {
5182       {
5183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5184       };
5185     } catch (std::exception& e) {
5186       {
5187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5188       };
5189     } catch (Dali::DaliException e) {
5190       {
5191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5192       };
5193     } catch (...) {
5194       {
5195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5196       };
5197     }
5198   }
5199
5200   jresult = result;
5201   return jresult;
5202 }
5203
5204
5205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5206   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5207
5208   arg1 = (Dali::Vector2 *)jarg1;
5209   {
5210     try {
5211       (arg1)->Normalize();
5212     } catch (std::out_of_range& e) {
5213       {
5214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5215       };
5216     } catch (std::exception& e) {
5217       {
5218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5219       };
5220     } catch (Dali::DaliException e) {
5221       {
5222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5223       };
5224     } catch (...) {
5225       {
5226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5227       };
5228     }
5229   }
5230
5231 }
5232
5233
5234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5235   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5236   Dali::Vector2 *arg2 = 0 ;
5237   Dali::Vector2 *arg3 = 0 ;
5238
5239   arg1 = (Dali::Vector2 *)jarg1;
5240   arg2 = (Dali::Vector2 *)jarg2;
5241   if (!arg2) {
5242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5243     return ;
5244   }
5245   arg3 = (Dali::Vector2 *)jarg3;
5246   if (!arg3) {
5247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5248     return ;
5249   }
5250   {
5251     try {
5252       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5253     } catch (std::out_of_range& e) {
5254       {
5255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5256       };
5257     } catch (std::exception& e) {
5258       {
5259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5260       };
5261     } catch (Dali::DaliException e) {
5262       {
5263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5264       };
5265     } catch (...) {
5266       {
5267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5268       };
5269     }
5270   }
5271
5272 }
5273
5274
5275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5276   void * jresult ;
5277   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5278   float *result = 0 ;
5279
5280   arg1 = (Dali::Vector2 *)jarg1;
5281   {
5282     try {
5283       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5284     } catch (std::out_of_range& e) {
5285       {
5286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5287       };
5288     } catch (std::exception& e) {
5289       {
5290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5291       };
5292     } catch (Dali::DaliException e) {
5293       {
5294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5295       };
5296     } catch (...) {
5297       {
5298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5299       };
5300     }
5301   }
5302
5303   jresult = (void *)result;
5304   return jresult;
5305 }
5306
5307
5308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5309   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5310   float arg2 ;
5311
5312   arg1 = (Dali::Vector2 *)jarg1;
5313   arg2 = (float)jarg2;
5314   if (arg1) (arg1)->x = arg2;
5315 }
5316
5317
5318 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5319   float jresult ;
5320   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5321   float result;
5322
5323   arg1 = (Dali::Vector2 *)jarg1;
5324   result = (float) ((arg1)->x);
5325   jresult = result;
5326   return jresult;
5327 }
5328
5329
5330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5331   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5332   float arg2 ;
5333
5334   arg1 = (Dali::Vector2 *)jarg1;
5335   arg2 = (float)jarg2;
5336   if (arg1) (arg1)->width = arg2;
5337 }
5338
5339
5340 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5341   float jresult ;
5342   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5343   float result;
5344
5345   arg1 = (Dali::Vector2 *)jarg1;
5346   result = (float) ((arg1)->width);
5347   jresult = result;
5348   return jresult;
5349 }
5350
5351
5352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5353   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5354   float arg2 ;
5355
5356   arg1 = (Dali::Vector2 *)jarg1;
5357   arg2 = (float)jarg2;
5358   if (arg1) (arg1)->y = arg2;
5359 }
5360
5361
5362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5363   float jresult ;
5364   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5365   float result;
5366
5367   arg1 = (Dali::Vector2 *)jarg1;
5368   result = (float) ((arg1)->y);
5369   jresult = result;
5370   return jresult;
5371 }
5372
5373
5374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5375   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5376   float arg2 ;
5377
5378   arg1 = (Dali::Vector2 *)jarg1;
5379   arg2 = (float)jarg2;
5380   if (arg1) (arg1)->height = arg2;
5381 }
5382
5383
5384 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5385   float jresult ;
5386   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5387   float result;
5388
5389   arg1 = (Dali::Vector2 *)jarg1;
5390   result = (float) ((arg1)->height);
5391   jresult = result;
5392   return jresult;
5393 }
5394
5395
5396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5397   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5398
5399   arg1 = (Dali::Vector2 *)jarg1;
5400   {
5401     try {
5402       delete arg1;
5403     } catch (std::out_of_range& e) {
5404       {
5405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5406       };
5407     } catch (std::exception& e) {
5408       {
5409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5410       };
5411     } catch (Dali::DaliException e) {
5412       {
5413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5414       };
5415     } catch (...) {
5416       {
5417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5418       };
5419     }
5420   }
5421
5422 }
5423
5424
5425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5426   void * jresult ;
5427   Dali::Vector2 *arg1 = 0 ;
5428   Dali::Vector2 *arg2 = 0 ;
5429   Dali::Vector2 result;
5430
5431   arg1 = (Dali::Vector2 *)jarg1;
5432   if (!arg1) {
5433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5434     return 0;
5435   }
5436   arg2 = (Dali::Vector2 *)jarg2;
5437   if (!arg2) {
5438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5439     return 0;
5440   }
5441   {
5442     try {
5443       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5444     } catch (std::out_of_range& e) {
5445       {
5446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5447       };
5448     } catch (std::exception& e) {
5449       {
5450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5451       };
5452     } catch (Dali::DaliException e) {
5453       {
5454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5455       };
5456     } catch (...) {
5457       {
5458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5459       };
5460     }
5461   }
5462
5463   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5464   return jresult;
5465 }
5466
5467
5468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5469   void * jresult ;
5470   Dali::Vector2 *arg1 = 0 ;
5471   Dali::Vector2 *arg2 = 0 ;
5472   Dali::Vector2 result;
5473
5474   arg1 = (Dali::Vector2 *)jarg1;
5475   if (!arg1) {
5476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5477     return 0;
5478   }
5479   arg2 = (Dali::Vector2 *)jarg2;
5480   if (!arg2) {
5481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5482     return 0;
5483   }
5484   {
5485     try {
5486       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5487     } catch (std::out_of_range& e) {
5488       {
5489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5490       };
5491     } catch (std::exception& e) {
5492       {
5493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5494       };
5495     } catch (Dali::DaliException e) {
5496       {
5497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5498       };
5499     } catch (...) {
5500       {
5501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5502       };
5503     }
5504   }
5505
5506   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5507   return jresult;
5508 }
5509
5510
5511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5512   void * jresult ;
5513   Dali::Vector2 *arg1 = 0 ;
5514   float *arg2 = 0 ;
5515   float *arg3 = 0 ;
5516   float temp2 ;
5517   float temp3 ;
5518   Dali::Vector2 result;
5519
5520   arg1 = (Dali::Vector2 *)jarg1;
5521   if (!arg1) {
5522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5523     return 0;
5524   }
5525   temp2 = (float)jarg2;
5526   arg2 = &temp2;
5527   temp3 = (float)jarg3;
5528   arg3 = &temp3;
5529   {
5530     try {
5531       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5532     } catch (std::out_of_range& e) {
5533       {
5534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5535       };
5536     } catch (std::exception& e) {
5537       {
5538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5539       };
5540     } catch (Dali::DaliException e) {
5541       {
5542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5543       };
5544     } catch (...) {
5545       {
5546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5547       };
5548     }
5549   }
5550
5551   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5552   return jresult;
5553 }
5554
5555
5556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5557   void * jresult ;
5558   Dali::Vector3 *result = 0 ;
5559
5560   {
5561     try {
5562       result = (Dali::Vector3 *)new Dali::Vector3();
5563     } catch (std::out_of_range& e) {
5564       {
5565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5566       };
5567     } catch (std::exception& e) {
5568       {
5569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5570       };
5571     } catch (Dali::DaliException e) {
5572       {
5573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5574       };
5575     } catch (...) {
5576       {
5577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5578       };
5579     }
5580   }
5581
5582   jresult = (void *)result;
5583   return jresult;
5584 }
5585
5586
5587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5588   void * jresult ;
5589   float arg1 ;
5590   float arg2 ;
5591   float arg3 ;
5592   Dali::Vector3 *result = 0 ;
5593
5594   arg1 = (float)jarg1;
5595   arg2 = (float)jarg2;
5596   arg3 = (float)jarg3;
5597   {
5598     try {
5599       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5600     } catch (std::out_of_range& e) {
5601       {
5602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5603       };
5604     } catch (std::exception& e) {
5605       {
5606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5607       };
5608     } catch (Dali::DaliException e) {
5609       {
5610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5611       };
5612     } catch (...) {
5613       {
5614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5615       };
5616     }
5617   }
5618
5619   jresult = (void *)result;
5620   return jresult;
5621 }
5622
5623
5624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5625   void * jresult ;
5626   float *arg1 = (float *) 0 ;
5627   Dali::Vector3 *result = 0 ;
5628
5629   arg1 = jarg1;
5630   {
5631     try {
5632       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5633     } catch (std::out_of_range& e) {
5634       {
5635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5636       };
5637     } catch (std::exception& e) {
5638       {
5639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5640       };
5641     } catch (Dali::DaliException e) {
5642       {
5643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5644       };
5645     } catch (...) {
5646       {
5647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5648       };
5649     }
5650   }
5651
5652   jresult = (void *)result;
5653
5654
5655   return jresult;
5656 }
5657
5658
5659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5660   void * jresult ;
5661   Dali::Vector2 *arg1 = 0 ;
5662   Dali::Vector3 *result = 0 ;
5663
5664   arg1 = (Dali::Vector2 *)jarg1;
5665   if (!arg1) {
5666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5667     return 0;
5668   }
5669   {
5670     try {
5671       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5672     } catch (std::out_of_range& e) {
5673       {
5674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5675       };
5676     } catch (std::exception& e) {
5677       {
5678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5679       };
5680     } catch (Dali::DaliException e) {
5681       {
5682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5683       };
5684     } catch (...) {
5685       {
5686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5687       };
5688     }
5689   }
5690
5691   jresult = (void *)result;
5692   return jresult;
5693 }
5694
5695
5696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5697   void * jresult ;
5698   Dali::Vector4 *arg1 = 0 ;
5699   Dali::Vector3 *result = 0 ;
5700
5701   arg1 = (Dali::Vector4 *)jarg1;
5702   if (!arg1) {
5703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5704     return 0;
5705   }
5706   {
5707     try {
5708       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5709     } catch (std::out_of_range& e) {
5710       {
5711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5712       };
5713     } catch (std::exception& e) {
5714       {
5715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5716       };
5717     } catch (Dali::DaliException e) {
5718       {
5719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5720       };
5721     } catch (...) {
5722       {
5723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5724       };
5725     }
5726   }
5727
5728   jresult = (void *)result;
5729   return jresult;
5730 }
5731
5732
5733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5734   void * jresult ;
5735   Dali::Vector3 *result = 0 ;
5736
5737   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5738   jresult = (void *)result;
5739   return jresult;
5740 }
5741
5742
5743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5744   void * jresult ;
5745   Dali::Vector3 *result = 0 ;
5746
5747   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5748   jresult = (void *)result;
5749   return jresult;
5750 }
5751
5752
5753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5754   void * jresult ;
5755   Dali::Vector3 *result = 0 ;
5756
5757   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5758   jresult = (void *)result;
5759   return jresult;
5760 }
5761
5762
5763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5764   void * jresult ;
5765   Dali::Vector3 *result = 0 ;
5766
5767   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5768   jresult = (void *)result;
5769   return jresult;
5770 }
5771
5772
5773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5774   void * jresult ;
5775   Dali::Vector3 *result = 0 ;
5776
5777   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5778   jresult = (void *)result;
5779   return jresult;
5780 }
5781
5782
5783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5784   void * jresult ;
5785   Dali::Vector3 *result = 0 ;
5786
5787   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5788   jresult = (void *)result;
5789   return jresult;
5790 }
5791
5792
5793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5794   void * jresult ;
5795   Dali::Vector3 *result = 0 ;
5796
5797   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5798   jresult = (void *)result;
5799   return jresult;
5800 }
5801
5802
5803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5804   void * jresult ;
5805   Dali::Vector3 *result = 0 ;
5806
5807   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5808   jresult = (void *)result;
5809   return jresult;
5810 }
5811
5812
5813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5814   void * jresult ;
5815   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5816   float *arg2 = (float *) 0 ;
5817   Dali::Vector3 *result = 0 ;
5818
5819   arg1 = (Dali::Vector3 *)jarg1;
5820   arg2 = jarg2;
5821   {
5822     try {
5823       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5824     } catch (std::out_of_range& e) {
5825       {
5826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5827       };
5828     } catch (std::exception& e) {
5829       {
5830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5831       };
5832     } catch (Dali::DaliException e) {
5833       {
5834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5835       };
5836     } catch (...) {
5837       {
5838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5839       };
5840     }
5841   }
5842
5843   jresult = (void *)result;
5844
5845
5846   return jresult;
5847 }
5848
5849
5850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5851   void * jresult ;
5852   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5853   Dali::Vector2 *arg2 = 0 ;
5854   Dali::Vector3 *result = 0 ;
5855
5856   arg1 = (Dali::Vector3 *)jarg1;
5857   arg2 = (Dali::Vector2 *)jarg2;
5858   if (!arg2) {
5859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5860     return 0;
5861   }
5862   {
5863     try {
5864       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5865     } catch (std::out_of_range& e) {
5866       {
5867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5868       };
5869     } catch (std::exception& e) {
5870       {
5871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5872       };
5873     } catch (Dali::DaliException e) {
5874       {
5875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5876       };
5877     } catch (...) {
5878       {
5879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5880       };
5881     }
5882   }
5883
5884   jresult = (void *)result;
5885   return jresult;
5886 }
5887
5888
5889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5890   void * jresult ;
5891   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5892   Dali::Vector4 *arg2 = 0 ;
5893   Dali::Vector3 *result = 0 ;
5894
5895   arg1 = (Dali::Vector3 *)jarg1;
5896   arg2 = (Dali::Vector4 *)jarg2;
5897   if (!arg2) {
5898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5899     return 0;
5900   }
5901   {
5902     try {
5903       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5904     } catch (std::out_of_range& e) {
5905       {
5906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5907       };
5908     } catch (std::exception& e) {
5909       {
5910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5911       };
5912     } catch (Dali::DaliException e) {
5913       {
5914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5915       };
5916     } catch (...) {
5917       {
5918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5919       };
5920     }
5921   }
5922
5923   jresult = (void *)result;
5924   return jresult;
5925 }
5926
5927
5928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5929   void * jresult ;
5930   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5931   Dali::Vector3 *arg2 = 0 ;
5932   Dali::Vector3 result;
5933
5934   arg1 = (Dali::Vector3 *)jarg1;
5935   arg2 = (Dali::Vector3 *)jarg2;
5936   if (!arg2) {
5937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5938     return 0;
5939   }
5940   {
5941     try {
5942       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5943     } catch (std::out_of_range& e) {
5944       {
5945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5946       };
5947     } catch (std::exception& e) {
5948       {
5949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5950       };
5951     } catch (Dali::DaliException e) {
5952       {
5953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5954       };
5955     } catch (...) {
5956       {
5957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5958       };
5959     }
5960   }
5961
5962   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5963   return jresult;
5964 }
5965
5966
5967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5968   void * jresult ;
5969   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5970   Dali::Vector3 *arg2 = 0 ;
5971   Dali::Vector3 *result = 0 ;
5972
5973   arg1 = (Dali::Vector3 *)jarg1;
5974   arg2 = (Dali::Vector3 *)jarg2;
5975   if (!arg2) {
5976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5977     return 0;
5978   }
5979   {
5980     try {
5981       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5982     } catch (std::out_of_range& e) {
5983       {
5984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5985       };
5986     } catch (std::exception& e) {
5987       {
5988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5989       };
5990     } catch (Dali::DaliException e) {
5991       {
5992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5993       };
5994     } catch (...) {
5995       {
5996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5997       };
5998     }
5999   }
6000
6001   jresult = (void *)result;
6002   return jresult;
6003 }
6004
6005
6006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6007   void * jresult ;
6008   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6009   Dali::Vector3 *arg2 = 0 ;
6010   Dali::Vector3 result;
6011
6012   arg1 = (Dali::Vector3 *)jarg1;
6013   arg2 = (Dali::Vector3 *)jarg2;
6014   if (!arg2) {
6015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6016     return 0;
6017   }
6018   {
6019     try {
6020       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6021     } catch (std::out_of_range& e) {
6022       {
6023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6024       };
6025     } catch (std::exception& e) {
6026       {
6027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6028       };
6029     } catch (Dali::DaliException e) {
6030       {
6031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6032       };
6033     } catch (...) {
6034       {
6035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6036       };
6037     }
6038   }
6039
6040   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6041   return jresult;
6042 }
6043
6044
6045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6046   void * jresult ;
6047   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6048   Dali::Vector3 *arg2 = 0 ;
6049   Dali::Vector3 *result = 0 ;
6050
6051   arg1 = (Dali::Vector3 *)jarg1;
6052   arg2 = (Dali::Vector3 *)jarg2;
6053   if (!arg2) {
6054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6055     return 0;
6056   }
6057   {
6058     try {
6059       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6060     } catch (std::out_of_range& e) {
6061       {
6062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6063       };
6064     } catch (std::exception& e) {
6065       {
6066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6067       };
6068     } catch (Dali::DaliException e) {
6069       {
6070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6071       };
6072     } catch (...) {
6073       {
6074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6075       };
6076     }
6077   }
6078
6079   jresult = (void *)result;
6080   return jresult;
6081 }
6082
6083
6084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6085   void * jresult ;
6086   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6087   Dali::Vector3 *arg2 = 0 ;
6088   Dali::Vector3 result;
6089
6090   arg1 = (Dali::Vector3 *)jarg1;
6091   arg2 = (Dali::Vector3 *)jarg2;
6092   if (!arg2) {
6093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6094     return 0;
6095   }
6096   {
6097     try {
6098       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6099     } catch (std::out_of_range& e) {
6100       {
6101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6102       };
6103     } catch (std::exception& e) {
6104       {
6105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6106       };
6107     } catch (Dali::DaliException e) {
6108       {
6109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6110       };
6111     } catch (...) {
6112       {
6113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6114       };
6115     }
6116   }
6117
6118   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6119   return jresult;
6120 }
6121
6122
6123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6124   void * jresult ;
6125   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6126   float arg2 ;
6127   Dali::Vector3 result;
6128
6129   arg1 = (Dali::Vector3 *)jarg1;
6130   arg2 = (float)jarg2;
6131   {
6132     try {
6133       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6134     } catch (std::out_of_range& e) {
6135       {
6136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6137       };
6138     } catch (std::exception& e) {
6139       {
6140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6141       };
6142     } catch (Dali::DaliException e) {
6143       {
6144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6145       };
6146     } catch (...) {
6147       {
6148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6149       };
6150     }
6151   }
6152
6153   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6154   return jresult;
6155 }
6156
6157
6158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6159   void * jresult ;
6160   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6161   Dali::Vector3 *arg2 = 0 ;
6162   Dali::Vector3 *result = 0 ;
6163
6164   arg1 = (Dali::Vector3 *)jarg1;
6165   arg2 = (Dali::Vector3 *)jarg2;
6166   if (!arg2) {
6167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6168     return 0;
6169   }
6170   {
6171     try {
6172       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6173     } catch (std::out_of_range& e) {
6174       {
6175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6176       };
6177     } catch (std::exception& e) {
6178       {
6179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6180       };
6181     } catch (Dali::DaliException e) {
6182       {
6183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6184       };
6185     } catch (...) {
6186       {
6187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6188       };
6189     }
6190   }
6191
6192   jresult = (void *)result;
6193   return jresult;
6194 }
6195
6196
6197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6198   void * jresult ;
6199   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6200   float arg2 ;
6201   Dali::Vector3 *result = 0 ;
6202
6203   arg1 = (Dali::Vector3 *)jarg1;
6204   arg2 = (float)jarg2;
6205   {
6206     try {
6207       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6208     } catch (std::out_of_range& e) {
6209       {
6210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6211       };
6212     } catch (std::exception& e) {
6213       {
6214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6215       };
6216     } catch (Dali::DaliException e) {
6217       {
6218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6219       };
6220     } catch (...) {
6221       {
6222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6223       };
6224     }
6225   }
6226
6227   jresult = (void *)result;
6228   return jresult;
6229 }
6230
6231
6232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6233   void * jresult ;
6234   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6235   Dali::Quaternion *arg2 = 0 ;
6236   Dali::Vector3 *result = 0 ;
6237
6238   arg1 = (Dali::Vector3 *)jarg1;
6239   arg2 = (Dali::Quaternion *)jarg2;
6240   if (!arg2) {
6241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6242     return 0;
6243   }
6244   {
6245     try {
6246       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6247     } catch (std::out_of_range& e) {
6248       {
6249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6250       };
6251     } catch (std::exception& e) {
6252       {
6253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6254       };
6255     } catch (Dali::DaliException e) {
6256       {
6257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6258       };
6259     } catch (...) {
6260       {
6261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6262       };
6263     }
6264   }
6265
6266   jresult = (void *)result;
6267   return jresult;
6268 }
6269
6270
6271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6272   void * jresult ;
6273   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6274   Dali::Vector3 *arg2 = 0 ;
6275   Dali::Vector3 result;
6276
6277   arg1 = (Dali::Vector3 *)jarg1;
6278   arg2 = (Dali::Vector3 *)jarg2;
6279   if (!arg2) {
6280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6281     return 0;
6282   }
6283   {
6284     try {
6285       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6286     } catch (std::out_of_range& e) {
6287       {
6288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6289       };
6290     } catch (std::exception& e) {
6291       {
6292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6293       };
6294     } catch (Dali::DaliException e) {
6295       {
6296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6297       };
6298     } catch (...) {
6299       {
6300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6301       };
6302     }
6303   }
6304
6305   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6306   return jresult;
6307 }
6308
6309
6310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6311   void * jresult ;
6312   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6313   float arg2 ;
6314   Dali::Vector3 result;
6315
6316   arg1 = (Dali::Vector3 *)jarg1;
6317   arg2 = (float)jarg2;
6318   {
6319     try {
6320       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6321     } catch (std::out_of_range& e) {
6322       {
6323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6324       };
6325     } catch (std::exception& e) {
6326       {
6327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6328       };
6329     } catch (Dali::DaliException e) {
6330       {
6331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6332       };
6333     } catch (...) {
6334       {
6335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6336       };
6337     }
6338   }
6339
6340   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6341   return jresult;
6342 }
6343
6344
6345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6346   void * jresult ;
6347   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6348   Dali::Vector3 *arg2 = 0 ;
6349   Dali::Vector3 *result = 0 ;
6350
6351   arg1 = (Dali::Vector3 *)jarg1;
6352   arg2 = (Dali::Vector3 *)jarg2;
6353   if (!arg2) {
6354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6355     return 0;
6356   }
6357   {
6358     try {
6359       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6360     } catch (std::out_of_range& e) {
6361       {
6362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6363       };
6364     } catch (std::exception& e) {
6365       {
6366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6367       };
6368     } catch (Dali::DaliException e) {
6369       {
6370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6371       };
6372     } catch (...) {
6373       {
6374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6375       };
6376     }
6377   }
6378
6379   jresult = (void *)result;
6380   return jresult;
6381 }
6382
6383
6384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6385   void * jresult ;
6386   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6387   float arg2 ;
6388   Dali::Vector3 *result = 0 ;
6389
6390   arg1 = (Dali::Vector3 *)jarg1;
6391   arg2 = (float)jarg2;
6392   {
6393     try {
6394       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6395     } catch (std::out_of_range& e) {
6396       {
6397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6398       };
6399     } catch (std::exception& e) {
6400       {
6401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6402       };
6403     } catch (Dali::DaliException e) {
6404       {
6405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6406       };
6407     } catch (...) {
6408       {
6409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6410       };
6411     }
6412   }
6413
6414   jresult = (void *)result;
6415   return jresult;
6416 }
6417
6418
6419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6420   void * jresult ;
6421   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6422   Dali::Vector3 result;
6423
6424   arg1 = (Dali::Vector3 *)jarg1;
6425   {
6426     try {
6427       result = ((Dali::Vector3 const *)arg1)->operator -();
6428     } catch (std::out_of_range& e) {
6429       {
6430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6431       };
6432     } catch (std::exception& e) {
6433       {
6434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6435       };
6436     } catch (Dali::DaliException e) {
6437       {
6438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6439       };
6440     } catch (...) {
6441       {
6442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6443       };
6444     }
6445   }
6446
6447   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6448   return jresult;
6449 }
6450
6451
6452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6453   unsigned int jresult ;
6454   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6455   Dali::Vector3 *arg2 = 0 ;
6456   bool result;
6457
6458   arg1 = (Dali::Vector3 *)jarg1;
6459   arg2 = (Dali::Vector3 *)jarg2;
6460   if (!arg2) {
6461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6462     return 0;
6463   }
6464   {
6465     try {
6466       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6467     } catch (std::out_of_range& e) {
6468       {
6469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6470       };
6471     } catch (std::exception& e) {
6472       {
6473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6474       };
6475     } catch (Dali::DaliException e) {
6476       {
6477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6478       };
6479     } catch (...) {
6480       {
6481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6482       };
6483     }
6484   }
6485
6486   jresult = result;
6487   return jresult;
6488 }
6489
6490
6491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6492   unsigned int jresult ;
6493   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6494   Dali::Vector3 *arg2 = 0 ;
6495   bool result;
6496
6497   arg1 = (Dali::Vector3 *)jarg1;
6498   arg2 = (Dali::Vector3 *)jarg2;
6499   if (!arg2) {
6500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6501     return 0;
6502   }
6503   {
6504     try {
6505       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6506     } catch (std::out_of_range& e) {
6507       {
6508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6509       };
6510     } catch (std::exception& e) {
6511       {
6512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6513       };
6514     } catch (Dali::DaliException e) {
6515       {
6516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6517       };
6518     } catch (...) {
6519       {
6520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6521       };
6522     }
6523   }
6524
6525   jresult = result;
6526   return jresult;
6527 }
6528
6529
6530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6531   float jresult ;
6532   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6533   unsigned int arg2 ;
6534   float *result = 0 ;
6535
6536   arg1 = (Dali::Vector3 *)jarg1;
6537   arg2 = (unsigned int)jarg2;
6538   {
6539     try {
6540       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6541     } catch (std::out_of_range& e) {
6542       {
6543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6544       };
6545     } catch (std::exception& e) {
6546       {
6547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6548       };
6549     } catch (Dali::DaliException e) {
6550       {
6551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6552       };
6553     } catch (...) {
6554       {
6555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6556       };
6557     }
6558   }
6559
6560   jresult = *result;
6561   return jresult;
6562 }
6563
6564
6565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6566   float jresult ;
6567   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6568   Dali::Vector3 *arg2 = 0 ;
6569   float result;
6570
6571   arg1 = (Dali::Vector3 *)jarg1;
6572   arg2 = (Dali::Vector3 *)jarg2;
6573   if (!arg2) {
6574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6575     return 0;
6576   }
6577   {
6578     try {
6579       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6580     } catch (std::out_of_range& e) {
6581       {
6582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6583       };
6584     } catch (std::exception& e) {
6585       {
6586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6587       };
6588     } catch (Dali::DaliException e) {
6589       {
6590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6591       };
6592     } catch (...) {
6593       {
6594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6595       };
6596     }
6597   }
6598
6599   jresult = result;
6600   return jresult;
6601 }
6602
6603
6604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6605   void * jresult ;
6606   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6607   Dali::Vector3 *arg2 = 0 ;
6608   Dali::Vector3 result;
6609
6610   arg1 = (Dali::Vector3 *)jarg1;
6611   arg2 = (Dali::Vector3 *)jarg2;
6612   if (!arg2) {
6613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6614     return 0;
6615   }
6616   {
6617     try {
6618       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6619     } catch (std::out_of_range& e) {
6620       {
6621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6622       };
6623     } catch (std::exception& e) {
6624       {
6625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6626       };
6627     } catch (Dali::DaliException e) {
6628       {
6629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6630       };
6631     } catch (...) {
6632       {
6633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6634       };
6635     }
6636   }
6637
6638   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6639   return jresult;
6640 }
6641
6642
6643 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6644   float jresult ;
6645   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6646   float result;
6647
6648   arg1 = (Dali::Vector3 *)jarg1;
6649   {
6650     try {
6651       result = (float)((Dali::Vector3 const *)arg1)->Length();
6652     } catch (std::out_of_range& e) {
6653       {
6654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6655       };
6656     } catch (std::exception& e) {
6657       {
6658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6659       };
6660     } catch (Dali::DaliException e) {
6661       {
6662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6663       };
6664     } catch (...) {
6665       {
6666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6667       };
6668     }
6669   }
6670
6671   jresult = result;
6672   return jresult;
6673 }
6674
6675
6676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6677   float jresult ;
6678   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6679   float result;
6680
6681   arg1 = (Dali::Vector3 *)jarg1;
6682   {
6683     try {
6684       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6685     } catch (std::out_of_range& e) {
6686       {
6687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6688       };
6689     } catch (std::exception& e) {
6690       {
6691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6692       };
6693     } catch (Dali::DaliException e) {
6694       {
6695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6696       };
6697     } catch (...) {
6698       {
6699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6700       };
6701     }
6702   }
6703
6704   jresult = result;
6705   return jresult;
6706 }
6707
6708
6709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6710   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6711
6712   arg1 = (Dali::Vector3 *)jarg1;
6713   {
6714     try {
6715       (arg1)->Normalize();
6716     } catch (std::out_of_range& e) {
6717       {
6718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6719       };
6720     } catch (std::exception& e) {
6721       {
6722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6723       };
6724     } catch (Dali::DaliException e) {
6725       {
6726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6727       };
6728     } catch (...) {
6729       {
6730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6731       };
6732     }
6733   }
6734
6735 }
6736
6737
6738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6739   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6740   Dali::Vector3 *arg2 = 0 ;
6741   Dali::Vector3 *arg3 = 0 ;
6742
6743   arg1 = (Dali::Vector3 *)jarg1;
6744   arg2 = (Dali::Vector3 *)jarg2;
6745   if (!arg2) {
6746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6747     return ;
6748   }
6749   arg3 = (Dali::Vector3 *)jarg3;
6750   if (!arg3) {
6751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6752     return ;
6753   }
6754   {
6755     try {
6756       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6757     } catch (std::out_of_range& e) {
6758       {
6759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6760       };
6761     } catch (std::exception& e) {
6762       {
6763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6764       };
6765     } catch (Dali::DaliException e) {
6766       {
6767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6768       };
6769     } catch (...) {
6770       {
6771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6772       };
6773     }
6774   }
6775
6776 }
6777
6778
6779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6780   void * jresult ;
6781   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6782   float *result = 0 ;
6783
6784   arg1 = (Dali::Vector3 *)jarg1;
6785   {
6786     try {
6787       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6788     } catch (std::out_of_range& e) {
6789       {
6790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6791       };
6792     } catch (std::exception& e) {
6793       {
6794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6795       };
6796     } catch (Dali::DaliException e) {
6797       {
6798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6799       };
6800     } catch (...) {
6801       {
6802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6803       };
6804     }
6805   }
6806
6807   jresult = (void *)result;
6808   return jresult;
6809 }
6810
6811
6812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6813   void * jresult ;
6814   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6815   Dali::Vector2 *result = 0 ;
6816
6817   arg1 = (Dali::Vector3 *)jarg1;
6818   {
6819     try {
6820       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6821     } catch (std::out_of_range& e) {
6822       {
6823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6824       };
6825     } catch (std::exception& e) {
6826       {
6827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6828       };
6829     } catch (Dali::DaliException e) {
6830       {
6831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6832       };
6833     } catch (...) {
6834       {
6835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6836       };
6837     }
6838   }
6839
6840   jresult = (void *)result;
6841   return jresult;
6842 }
6843
6844
6845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6846   void * jresult ;
6847   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6848   Dali::Vector2 *result = 0 ;
6849
6850   arg1 = (Dali::Vector3 *)jarg1;
6851   {
6852     try {
6853       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6854     } catch (std::out_of_range& e) {
6855       {
6856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6857       };
6858     } catch (std::exception& e) {
6859       {
6860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6861       };
6862     } catch (Dali::DaliException e) {
6863       {
6864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6865       };
6866     } catch (...) {
6867       {
6868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6869       };
6870     }
6871   }
6872
6873   jresult = (void *)result;
6874   return jresult;
6875 }
6876
6877
6878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6879   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6880   float arg2 ;
6881
6882   arg1 = (Dali::Vector3 *)jarg1;
6883   arg2 = (float)jarg2;
6884   if (arg1) (arg1)->x = arg2;
6885 }
6886
6887
6888 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6889   float jresult ;
6890   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6891   float result;
6892
6893   arg1 = (Dali::Vector3 *)jarg1;
6894   result = (float) ((arg1)->x);
6895   jresult = result;
6896   return jresult;
6897 }
6898
6899
6900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6901   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6902   float arg2 ;
6903
6904   arg1 = (Dali::Vector3 *)jarg1;
6905   arg2 = (float)jarg2;
6906   if (arg1) (arg1)->width = arg2;
6907 }
6908
6909
6910 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6911   float jresult ;
6912   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6913   float result;
6914
6915   arg1 = (Dali::Vector3 *)jarg1;
6916   result = (float) ((arg1)->width);
6917   jresult = result;
6918   return jresult;
6919 }
6920
6921
6922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6923   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6924   float arg2 ;
6925
6926   arg1 = (Dali::Vector3 *)jarg1;
6927   arg2 = (float)jarg2;
6928   if (arg1) (arg1)->r = arg2;
6929 }
6930
6931
6932 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6933   float jresult ;
6934   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6935   float result;
6936
6937   arg1 = (Dali::Vector3 *)jarg1;
6938   result = (float) ((arg1)->r);
6939   jresult = result;
6940   return jresult;
6941 }
6942
6943
6944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6945   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6946   float arg2 ;
6947
6948   arg1 = (Dali::Vector3 *)jarg1;
6949   arg2 = (float)jarg2;
6950   if (arg1) (arg1)->y = arg2;
6951 }
6952
6953
6954 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6955   float jresult ;
6956   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6957   float result;
6958
6959   arg1 = (Dali::Vector3 *)jarg1;
6960   result = (float) ((arg1)->y);
6961   jresult = result;
6962   return jresult;
6963 }
6964
6965
6966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6967   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6968   float arg2 ;
6969
6970   arg1 = (Dali::Vector3 *)jarg1;
6971   arg2 = (float)jarg2;
6972   if (arg1) (arg1)->height = arg2;
6973 }
6974
6975
6976 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6977   float jresult ;
6978   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6979   float result;
6980
6981   arg1 = (Dali::Vector3 *)jarg1;
6982   result = (float) ((arg1)->height);
6983   jresult = result;
6984   return jresult;
6985 }
6986
6987
6988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6989   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6990   float arg2 ;
6991
6992   arg1 = (Dali::Vector3 *)jarg1;
6993   arg2 = (float)jarg2;
6994   if (arg1) (arg1)->g = arg2;
6995 }
6996
6997
6998 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6999   float jresult ;
7000   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7001   float result;
7002
7003   arg1 = (Dali::Vector3 *)jarg1;
7004   result = (float) ((arg1)->g);
7005   jresult = result;
7006   return jresult;
7007 }
7008
7009
7010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7011   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7012   float arg2 ;
7013
7014   arg1 = (Dali::Vector3 *)jarg1;
7015   arg2 = (float)jarg2;
7016   if (arg1) (arg1)->z = arg2;
7017 }
7018
7019
7020 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7021   float jresult ;
7022   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7023   float result;
7024
7025   arg1 = (Dali::Vector3 *)jarg1;
7026   result = (float) ((arg1)->z);
7027   jresult = result;
7028   return jresult;
7029 }
7030
7031
7032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7033   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7034   float arg2 ;
7035
7036   arg1 = (Dali::Vector3 *)jarg1;
7037   arg2 = (float)jarg2;
7038   if (arg1) (arg1)->depth = arg2;
7039 }
7040
7041
7042 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7043   float jresult ;
7044   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7045   float result;
7046
7047   arg1 = (Dali::Vector3 *)jarg1;
7048   result = (float) ((arg1)->depth);
7049   jresult = result;
7050   return jresult;
7051 }
7052
7053
7054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7055   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7056   float arg2 ;
7057
7058   arg1 = (Dali::Vector3 *)jarg1;
7059   arg2 = (float)jarg2;
7060   if (arg1) (arg1)->b = arg2;
7061 }
7062
7063
7064 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7065   float jresult ;
7066   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7067   float result;
7068
7069   arg1 = (Dali::Vector3 *)jarg1;
7070   result = (float) ((arg1)->b);
7071   jresult = result;
7072   return jresult;
7073 }
7074
7075
7076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7077   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7078
7079   arg1 = (Dali::Vector3 *)jarg1;
7080   {
7081     try {
7082       delete arg1;
7083     } catch (std::out_of_range& e) {
7084       {
7085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7086       };
7087     } catch (std::exception& e) {
7088       {
7089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7090       };
7091     } catch (Dali::DaliException e) {
7092       {
7093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7094       };
7095     } catch (...) {
7096       {
7097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7098       };
7099     }
7100   }
7101
7102 }
7103
7104
7105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7106   void * jresult ;
7107   Dali::Vector3 *arg1 = 0 ;
7108   Dali::Vector3 *arg2 = 0 ;
7109   Dali::Vector3 result;
7110
7111   arg1 = (Dali::Vector3 *)jarg1;
7112   if (!arg1) {
7113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7114     return 0;
7115   }
7116   arg2 = (Dali::Vector3 *)jarg2;
7117   if (!arg2) {
7118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7119     return 0;
7120   }
7121   {
7122     try {
7123       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7124     } catch (std::out_of_range& e) {
7125       {
7126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7127       };
7128     } catch (std::exception& e) {
7129       {
7130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7131       };
7132     } catch (Dali::DaliException e) {
7133       {
7134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7135       };
7136     } catch (...) {
7137       {
7138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7139       };
7140     }
7141   }
7142
7143   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7144   return jresult;
7145 }
7146
7147
7148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7149   void * jresult ;
7150   Dali::Vector3 *arg1 = 0 ;
7151   Dali::Vector3 *arg2 = 0 ;
7152   Dali::Vector3 result;
7153
7154   arg1 = (Dali::Vector3 *)jarg1;
7155   if (!arg1) {
7156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7157     return 0;
7158   }
7159   arg2 = (Dali::Vector3 *)jarg2;
7160   if (!arg2) {
7161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7162     return 0;
7163   }
7164   {
7165     try {
7166       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7167     } catch (std::out_of_range& e) {
7168       {
7169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7170       };
7171     } catch (std::exception& e) {
7172       {
7173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7174       };
7175     } catch (Dali::DaliException e) {
7176       {
7177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7178       };
7179     } catch (...) {
7180       {
7181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7182       };
7183     }
7184   }
7185
7186   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7187   return jresult;
7188 }
7189
7190
7191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7192   void * jresult ;
7193   Dali::Vector3 *arg1 = 0 ;
7194   float *arg2 = 0 ;
7195   float *arg3 = 0 ;
7196   float temp2 ;
7197   float temp3 ;
7198   Dali::Vector3 result;
7199
7200   arg1 = (Dali::Vector3 *)jarg1;
7201   if (!arg1) {
7202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7203     return 0;
7204   }
7205   temp2 = (float)jarg2;
7206   arg2 = &temp2;
7207   temp3 = (float)jarg3;
7208   arg3 = &temp3;
7209   {
7210     try {
7211       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7212     } catch (std::out_of_range& e) {
7213       {
7214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7215       };
7216     } catch (std::exception& e) {
7217       {
7218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7219       };
7220     } catch (Dali::DaliException e) {
7221       {
7222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7223       };
7224     } catch (...) {
7225       {
7226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7227       };
7228     }
7229   }
7230
7231   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7232   return jresult;
7233 }
7234
7235
7236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7237   void * jresult ;
7238   Dali::Vector4 *result = 0 ;
7239
7240   {
7241     try {
7242       result = (Dali::Vector4 *)new Dali::Vector4();
7243     } catch (std::out_of_range& e) {
7244       {
7245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7246       };
7247     } catch (std::exception& e) {
7248       {
7249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7250       };
7251     } catch (Dali::DaliException e) {
7252       {
7253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7254       };
7255     } catch (...) {
7256       {
7257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7258       };
7259     }
7260   }
7261
7262   jresult = (void *)result;
7263   return jresult;
7264 }
7265
7266
7267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7268   void * jresult ;
7269   float arg1 ;
7270   float arg2 ;
7271   float arg3 ;
7272   float arg4 ;
7273   Dali::Vector4 *result = 0 ;
7274
7275   arg1 = (float)jarg1;
7276   arg2 = (float)jarg2;
7277   arg3 = (float)jarg3;
7278   arg4 = (float)jarg4;
7279   {
7280     try {
7281       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7282     } catch (std::out_of_range& e) {
7283       {
7284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7285       };
7286     } catch (std::exception& e) {
7287       {
7288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7289       };
7290     } catch (Dali::DaliException e) {
7291       {
7292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7293       };
7294     } catch (...) {
7295       {
7296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7297       };
7298     }
7299   }
7300
7301   jresult = (void *)result;
7302   return jresult;
7303 }
7304
7305
7306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7307   void * jresult ;
7308   float *arg1 = (float *) 0 ;
7309   Dali::Vector4 *result = 0 ;
7310
7311   arg1 = jarg1;
7312   {
7313     try {
7314       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7315     } catch (std::out_of_range& e) {
7316       {
7317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7318       };
7319     } catch (std::exception& e) {
7320       {
7321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7322       };
7323     } catch (Dali::DaliException e) {
7324       {
7325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7326       };
7327     } catch (...) {
7328       {
7329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7330       };
7331     }
7332   }
7333
7334   jresult = (void *)result;
7335
7336
7337   return jresult;
7338 }
7339
7340
7341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7342   void * jresult ;
7343   Dali::Vector2 *arg1 = 0 ;
7344   Dali::Vector4 *result = 0 ;
7345
7346   arg1 = (Dali::Vector2 *)jarg1;
7347   if (!arg1) {
7348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7349     return 0;
7350   }
7351   {
7352     try {
7353       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7354     } catch (std::out_of_range& e) {
7355       {
7356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7357       };
7358     } catch (std::exception& e) {
7359       {
7360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7361       };
7362     } catch (Dali::DaliException e) {
7363       {
7364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7365       };
7366     } catch (...) {
7367       {
7368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7369       };
7370     }
7371   }
7372
7373   jresult = (void *)result;
7374   return jresult;
7375 }
7376
7377
7378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7379   void * jresult ;
7380   Dali::Vector3 *arg1 = 0 ;
7381   Dali::Vector4 *result = 0 ;
7382
7383   arg1 = (Dali::Vector3 *)jarg1;
7384   if (!arg1) {
7385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7386     return 0;
7387   }
7388   {
7389     try {
7390       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7391     } catch (std::out_of_range& e) {
7392       {
7393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7394       };
7395     } catch (std::exception& e) {
7396       {
7397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7398       };
7399     } catch (Dali::DaliException e) {
7400       {
7401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7402       };
7403     } catch (...) {
7404       {
7405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7406       };
7407     }
7408   }
7409
7410   jresult = (void *)result;
7411   return jresult;
7412 }
7413
7414
7415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7416   void * jresult ;
7417   Dali::Vector4 *result = 0 ;
7418
7419   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7420   jresult = (void *)result;
7421   return jresult;
7422 }
7423
7424
7425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7426   void * jresult ;
7427   Dali::Vector4 *result = 0 ;
7428
7429   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7430   jresult = (void *)result;
7431   return jresult;
7432 }
7433
7434
7435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7436   void * jresult ;
7437   Dali::Vector4 *result = 0 ;
7438
7439   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7440   jresult = (void *)result;
7441   return jresult;
7442 }
7443
7444
7445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7446   void * jresult ;
7447   Dali::Vector4 *result = 0 ;
7448
7449   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7450   jresult = (void *)result;
7451   return jresult;
7452 }
7453
7454
7455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7456   void * jresult ;
7457   Dali::Vector4 *result = 0 ;
7458
7459   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7460   jresult = (void *)result;
7461   return jresult;
7462 }
7463
7464
7465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7466   void * jresult ;
7467   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7468   float *arg2 = (float *) 0 ;
7469   Dali::Vector4 *result = 0 ;
7470
7471   arg1 = (Dali::Vector4 *)jarg1;
7472   arg2 = jarg2;
7473   {
7474     try {
7475       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7476     } catch (std::out_of_range& e) {
7477       {
7478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7479       };
7480     } catch (std::exception& e) {
7481       {
7482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7483       };
7484     } catch (Dali::DaliException e) {
7485       {
7486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7487       };
7488     } catch (...) {
7489       {
7490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7491       };
7492     }
7493   }
7494
7495   jresult = (void *)result;
7496
7497
7498   return jresult;
7499 }
7500
7501
7502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7503   void * jresult ;
7504   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7505   Dali::Vector2 *arg2 = 0 ;
7506   Dali::Vector4 *result = 0 ;
7507
7508   arg1 = (Dali::Vector4 *)jarg1;
7509   arg2 = (Dali::Vector2 *)jarg2;
7510   if (!arg2) {
7511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7512     return 0;
7513   }
7514   {
7515     try {
7516       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7517     } catch (std::out_of_range& e) {
7518       {
7519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7520       };
7521     } catch (std::exception& e) {
7522       {
7523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7524       };
7525     } catch (Dali::DaliException e) {
7526       {
7527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7528       };
7529     } catch (...) {
7530       {
7531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7532       };
7533     }
7534   }
7535
7536   jresult = (void *)result;
7537   return jresult;
7538 }
7539
7540
7541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7542   void * jresult ;
7543   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7544   Dali::Vector3 *arg2 = 0 ;
7545   Dali::Vector4 *result = 0 ;
7546
7547   arg1 = (Dali::Vector4 *)jarg1;
7548   arg2 = (Dali::Vector3 *)jarg2;
7549   if (!arg2) {
7550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7551     return 0;
7552   }
7553   {
7554     try {
7555       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7556     } catch (std::out_of_range& e) {
7557       {
7558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7559       };
7560     } catch (std::exception& e) {
7561       {
7562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7563       };
7564     } catch (Dali::DaliException e) {
7565       {
7566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7567       };
7568     } catch (...) {
7569       {
7570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7571       };
7572     }
7573   }
7574
7575   jresult = (void *)result;
7576   return jresult;
7577 }
7578
7579
7580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7581   void * jresult ;
7582   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7583   Dali::Vector4 *arg2 = 0 ;
7584   Dali::Vector4 result;
7585
7586   arg1 = (Dali::Vector4 *)jarg1;
7587   arg2 = (Dali::Vector4 *)jarg2;
7588   if (!arg2) {
7589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7590     return 0;
7591   }
7592   {
7593     try {
7594       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7595     } catch (std::out_of_range& e) {
7596       {
7597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7598       };
7599     } catch (std::exception& e) {
7600       {
7601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7602       };
7603     } catch (Dali::DaliException e) {
7604       {
7605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7606       };
7607     } catch (...) {
7608       {
7609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7610       };
7611     }
7612   }
7613
7614   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7615   return jresult;
7616 }
7617
7618
7619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7620   void * jresult ;
7621   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7622   Dali::Vector4 *arg2 = 0 ;
7623   Dali::Vector4 *result = 0 ;
7624
7625   arg1 = (Dali::Vector4 *)jarg1;
7626   arg2 = (Dali::Vector4 *)jarg2;
7627   if (!arg2) {
7628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7629     return 0;
7630   }
7631   {
7632     try {
7633       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7634     } catch (std::out_of_range& e) {
7635       {
7636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7637       };
7638     } catch (std::exception& e) {
7639       {
7640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7641       };
7642     } catch (Dali::DaliException e) {
7643       {
7644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7645       };
7646     } catch (...) {
7647       {
7648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7649       };
7650     }
7651   }
7652
7653   jresult = (void *)result;
7654   return jresult;
7655 }
7656
7657
7658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7659   void * jresult ;
7660   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7661   Dali::Vector4 *arg2 = 0 ;
7662   Dali::Vector4 result;
7663
7664   arg1 = (Dali::Vector4 *)jarg1;
7665   arg2 = (Dali::Vector4 *)jarg2;
7666   if (!arg2) {
7667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7668     return 0;
7669   }
7670   {
7671     try {
7672       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7673     } catch (std::out_of_range& e) {
7674       {
7675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7676       };
7677     } catch (std::exception& e) {
7678       {
7679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7680       };
7681     } catch (Dali::DaliException e) {
7682       {
7683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7684       };
7685     } catch (...) {
7686       {
7687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7688       };
7689     }
7690   }
7691
7692   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7693   return jresult;
7694 }
7695
7696
7697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7698   void * jresult ;
7699   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7700   Dali::Vector4 *arg2 = 0 ;
7701   Dali::Vector4 *result = 0 ;
7702
7703   arg1 = (Dali::Vector4 *)jarg1;
7704   arg2 = (Dali::Vector4 *)jarg2;
7705   if (!arg2) {
7706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7707     return 0;
7708   }
7709   {
7710     try {
7711       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7712     } catch (std::out_of_range& e) {
7713       {
7714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7715       };
7716     } catch (std::exception& e) {
7717       {
7718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7719       };
7720     } catch (Dali::DaliException e) {
7721       {
7722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7723       };
7724     } catch (...) {
7725       {
7726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7727       };
7728     }
7729   }
7730
7731   jresult = (void *)result;
7732   return jresult;
7733 }
7734
7735
7736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7737   void * jresult ;
7738   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7739   Dali::Vector4 *arg2 = 0 ;
7740   Dali::Vector4 result;
7741
7742   arg1 = (Dali::Vector4 *)jarg1;
7743   arg2 = (Dali::Vector4 *)jarg2;
7744   if (!arg2) {
7745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7746     return 0;
7747   }
7748   {
7749     try {
7750       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7751     } catch (std::out_of_range& e) {
7752       {
7753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7754       };
7755     } catch (std::exception& e) {
7756       {
7757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7758       };
7759     } catch (Dali::DaliException e) {
7760       {
7761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7762       };
7763     } catch (...) {
7764       {
7765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7766       };
7767     }
7768   }
7769
7770   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7771   return jresult;
7772 }
7773
7774
7775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7776   void * jresult ;
7777   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7778   float arg2 ;
7779   Dali::Vector4 result;
7780
7781   arg1 = (Dali::Vector4 *)jarg1;
7782   arg2 = (float)jarg2;
7783   {
7784     try {
7785       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7786     } catch (std::out_of_range& e) {
7787       {
7788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7789       };
7790     } catch (std::exception& e) {
7791       {
7792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7793       };
7794     } catch (Dali::DaliException e) {
7795       {
7796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7797       };
7798     } catch (...) {
7799       {
7800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7801       };
7802     }
7803   }
7804
7805   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7806   return jresult;
7807 }
7808
7809
7810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7811   void * jresult ;
7812   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7813   Dali::Vector4 *arg2 = 0 ;
7814   Dali::Vector4 *result = 0 ;
7815
7816   arg1 = (Dali::Vector4 *)jarg1;
7817   arg2 = (Dali::Vector4 *)jarg2;
7818   if (!arg2) {
7819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7820     return 0;
7821   }
7822   {
7823     try {
7824       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7825     } catch (std::out_of_range& e) {
7826       {
7827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7828       };
7829     } catch (std::exception& e) {
7830       {
7831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7832       };
7833     } catch (Dali::DaliException e) {
7834       {
7835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7836       };
7837     } catch (...) {
7838       {
7839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7840       };
7841     }
7842   }
7843
7844   jresult = (void *)result;
7845   return jresult;
7846 }
7847
7848
7849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7850   void * jresult ;
7851   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7852   float arg2 ;
7853   Dali::Vector4 *result = 0 ;
7854
7855   arg1 = (Dali::Vector4 *)jarg1;
7856   arg2 = (float)jarg2;
7857   {
7858     try {
7859       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7860     } catch (std::out_of_range& e) {
7861       {
7862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7863       };
7864     } catch (std::exception& e) {
7865       {
7866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7867       };
7868     } catch (Dali::DaliException e) {
7869       {
7870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7871       };
7872     } catch (...) {
7873       {
7874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7875       };
7876     }
7877   }
7878
7879   jresult = (void *)result;
7880   return jresult;
7881 }
7882
7883
7884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7885   void * jresult ;
7886   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7887   Dali::Vector4 *arg2 = 0 ;
7888   Dali::Vector4 result;
7889
7890   arg1 = (Dali::Vector4 *)jarg1;
7891   arg2 = (Dali::Vector4 *)jarg2;
7892   if (!arg2) {
7893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7894     return 0;
7895   }
7896   {
7897     try {
7898       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7899     } catch (std::out_of_range& e) {
7900       {
7901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7902       };
7903     } catch (std::exception& e) {
7904       {
7905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7906       };
7907     } catch (Dali::DaliException e) {
7908       {
7909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7910       };
7911     } catch (...) {
7912       {
7913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7914       };
7915     }
7916   }
7917
7918   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7919   return jresult;
7920 }
7921
7922
7923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7924   void * jresult ;
7925   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7926   float arg2 ;
7927   Dali::Vector4 result;
7928
7929   arg1 = (Dali::Vector4 *)jarg1;
7930   arg2 = (float)jarg2;
7931   {
7932     try {
7933       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7934     } catch (std::out_of_range& e) {
7935       {
7936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7937       };
7938     } catch (std::exception& e) {
7939       {
7940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7941       };
7942     } catch (Dali::DaliException e) {
7943       {
7944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7945       };
7946     } catch (...) {
7947       {
7948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7949       };
7950     }
7951   }
7952
7953   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7954   return jresult;
7955 }
7956
7957
7958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7959   void * jresult ;
7960   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7961   Dali::Vector4 *arg2 = 0 ;
7962   Dali::Vector4 *result = 0 ;
7963
7964   arg1 = (Dali::Vector4 *)jarg1;
7965   arg2 = (Dali::Vector4 *)jarg2;
7966   if (!arg2) {
7967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7968     return 0;
7969   }
7970   {
7971     try {
7972       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7973     } catch (std::out_of_range& e) {
7974       {
7975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7976       };
7977     } catch (std::exception& e) {
7978       {
7979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7980       };
7981     } catch (Dali::DaliException e) {
7982       {
7983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7984       };
7985     } catch (...) {
7986       {
7987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7988       };
7989     }
7990   }
7991
7992   jresult = (void *)result;
7993   return jresult;
7994 }
7995
7996
7997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7998   void * jresult ;
7999   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8000   float arg2 ;
8001   Dali::Vector4 *result = 0 ;
8002
8003   arg1 = (Dali::Vector4 *)jarg1;
8004   arg2 = (float)jarg2;
8005   {
8006     try {
8007       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8008     } catch (std::out_of_range& e) {
8009       {
8010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8011       };
8012     } catch (std::exception& e) {
8013       {
8014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8015       };
8016     } catch (Dali::DaliException e) {
8017       {
8018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8019       };
8020     } catch (...) {
8021       {
8022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8023       };
8024     }
8025   }
8026
8027   jresult = (void *)result;
8028   return jresult;
8029 }
8030
8031
8032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8033   void * jresult ;
8034   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8035   Dali::Vector4 result;
8036
8037   arg1 = (Dali::Vector4 *)jarg1;
8038   {
8039     try {
8040       result = ((Dali::Vector4 const *)arg1)->operator -();
8041     } catch (std::out_of_range& e) {
8042       {
8043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8044       };
8045     } catch (std::exception& e) {
8046       {
8047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8048       };
8049     } catch (Dali::DaliException e) {
8050       {
8051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8052       };
8053     } catch (...) {
8054       {
8055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8056       };
8057     }
8058   }
8059
8060   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8061   return jresult;
8062 }
8063
8064
8065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8066   unsigned int jresult ;
8067   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8068   Dali::Vector4 *arg2 = 0 ;
8069   bool result;
8070
8071   arg1 = (Dali::Vector4 *)jarg1;
8072   arg2 = (Dali::Vector4 *)jarg2;
8073   if (!arg2) {
8074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8075     return 0;
8076   }
8077   {
8078     try {
8079       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8080     } catch (std::out_of_range& e) {
8081       {
8082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8083       };
8084     } catch (std::exception& e) {
8085       {
8086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8087       };
8088     } catch (Dali::DaliException e) {
8089       {
8090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8091       };
8092     } catch (...) {
8093       {
8094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8095       };
8096     }
8097   }
8098
8099   jresult = result;
8100   return jresult;
8101 }
8102
8103
8104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8105   unsigned int jresult ;
8106   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8107   Dali::Vector4 *arg2 = 0 ;
8108   bool result;
8109
8110   arg1 = (Dali::Vector4 *)jarg1;
8111   arg2 = (Dali::Vector4 *)jarg2;
8112   if (!arg2) {
8113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8114     return 0;
8115   }
8116   {
8117     try {
8118       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8119     } catch (std::out_of_range& e) {
8120       {
8121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8122       };
8123     } catch (std::exception& e) {
8124       {
8125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8126       };
8127     } catch (Dali::DaliException e) {
8128       {
8129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8130       };
8131     } catch (...) {
8132       {
8133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8134       };
8135     }
8136   }
8137
8138   jresult = result;
8139   return jresult;
8140 }
8141
8142
8143 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8144   float jresult ;
8145   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8146   unsigned int arg2 ;
8147   float *result = 0 ;
8148
8149   arg1 = (Dali::Vector4 *)jarg1;
8150   arg2 = (unsigned int)jarg2;
8151   {
8152     try {
8153       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8154     } catch (std::out_of_range& e) {
8155       {
8156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8157       };
8158     } catch (std::exception& e) {
8159       {
8160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8161       };
8162     } catch (Dali::DaliException e) {
8163       {
8164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8165       };
8166     } catch (...) {
8167       {
8168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8169       };
8170     }
8171   }
8172
8173   jresult = *result;
8174   return jresult;
8175 }
8176
8177
8178 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8179   float jresult ;
8180   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8181   Dali::Vector3 *arg2 = 0 ;
8182   float result;
8183
8184   arg1 = (Dali::Vector4 *)jarg1;
8185   arg2 = (Dali::Vector3 *)jarg2;
8186   if (!arg2) {
8187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8188     return 0;
8189   }
8190   {
8191     try {
8192       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8193     } catch (std::out_of_range& e) {
8194       {
8195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8196       };
8197     } catch (std::exception& e) {
8198       {
8199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8200       };
8201     } catch (Dali::DaliException e) {
8202       {
8203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8204       };
8205     } catch (...) {
8206       {
8207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8208       };
8209     }
8210   }
8211
8212   jresult = result;
8213   return jresult;
8214 }
8215
8216
8217 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8218   float jresult ;
8219   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8220   Dali::Vector4 *arg2 = 0 ;
8221   float result;
8222
8223   arg1 = (Dali::Vector4 *)jarg1;
8224   arg2 = (Dali::Vector4 *)jarg2;
8225   if (!arg2) {
8226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8227     return 0;
8228   }
8229   {
8230     try {
8231       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8232     } catch (std::out_of_range& e) {
8233       {
8234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8235       };
8236     } catch (std::exception& e) {
8237       {
8238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8239       };
8240     } catch (Dali::DaliException e) {
8241       {
8242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8243       };
8244     } catch (...) {
8245       {
8246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8247       };
8248     }
8249   }
8250
8251   jresult = result;
8252   return jresult;
8253 }
8254
8255
8256 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8257   float jresult ;
8258   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8259   Dali::Vector4 *arg2 = 0 ;
8260   float result;
8261
8262   arg1 = (Dali::Vector4 *)jarg1;
8263   arg2 = (Dali::Vector4 *)jarg2;
8264   if (!arg2) {
8265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8266     return 0;
8267   }
8268   {
8269     try {
8270       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8271     } catch (std::out_of_range& e) {
8272       {
8273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8274       };
8275     } catch (std::exception& e) {
8276       {
8277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8278       };
8279     } catch (Dali::DaliException e) {
8280       {
8281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8282       };
8283     } catch (...) {
8284       {
8285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8286       };
8287     }
8288   }
8289
8290   jresult = result;
8291   return jresult;
8292 }
8293
8294
8295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8296   void * jresult ;
8297   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8298   Dali::Vector4 *arg2 = 0 ;
8299   Dali::Vector4 result;
8300
8301   arg1 = (Dali::Vector4 *)jarg1;
8302   arg2 = (Dali::Vector4 *)jarg2;
8303   if (!arg2) {
8304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8305     return 0;
8306   }
8307   {
8308     try {
8309       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8310     } catch (std::out_of_range& e) {
8311       {
8312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8313       };
8314     } catch (std::exception& e) {
8315       {
8316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8317       };
8318     } catch (Dali::DaliException e) {
8319       {
8320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8321       };
8322     } catch (...) {
8323       {
8324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8325       };
8326     }
8327   }
8328
8329   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8330   return jresult;
8331 }
8332
8333
8334 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8335   float jresult ;
8336   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8337   float result;
8338
8339   arg1 = (Dali::Vector4 *)jarg1;
8340   {
8341     try {
8342       result = (float)((Dali::Vector4 const *)arg1)->Length();
8343     } catch (std::out_of_range& e) {
8344       {
8345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8346       };
8347     } catch (std::exception& e) {
8348       {
8349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8350       };
8351     } catch (Dali::DaliException e) {
8352       {
8353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8354       };
8355     } catch (...) {
8356       {
8357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8358       };
8359     }
8360   }
8361
8362   jresult = result;
8363   return jresult;
8364 }
8365
8366
8367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8368   float jresult ;
8369   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8370   float result;
8371
8372   arg1 = (Dali::Vector4 *)jarg1;
8373   {
8374     try {
8375       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8376     } catch (std::out_of_range& e) {
8377       {
8378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8379       };
8380     } catch (std::exception& e) {
8381       {
8382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8383       };
8384     } catch (Dali::DaliException e) {
8385       {
8386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8387       };
8388     } catch (...) {
8389       {
8390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8391       };
8392     }
8393   }
8394
8395   jresult = result;
8396   return jresult;
8397 }
8398
8399
8400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8401   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8402
8403   arg1 = (Dali::Vector4 *)jarg1;
8404   {
8405     try {
8406       (arg1)->Normalize();
8407     } catch (std::out_of_range& e) {
8408       {
8409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8410       };
8411     } catch (std::exception& e) {
8412       {
8413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8414       };
8415     } catch (Dali::DaliException e) {
8416       {
8417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8418       };
8419     } catch (...) {
8420       {
8421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8422       };
8423     }
8424   }
8425
8426 }
8427
8428
8429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8430   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8431   Dali::Vector4 *arg2 = 0 ;
8432   Dali::Vector4 *arg3 = 0 ;
8433
8434   arg1 = (Dali::Vector4 *)jarg1;
8435   arg2 = (Dali::Vector4 *)jarg2;
8436   if (!arg2) {
8437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8438     return ;
8439   }
8440   arg3 = (Dali::Vector4 *)jarg3;
8441   if (!arg3) {
8442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8443     return ;
8444   }
8445   {
8446     try {
8447       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8448     } catch (std::out_of_range& e) {
8449       {
8450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8451       };
8452     } catch (std::exception& e) {
8453       {
8454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8455       };
8456     } catch (Dali::DaliException e) {
8457       {
8458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8459       };
8460     } catch (...) {
8461       {
8462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8463       };
8464     }
8465   }
8466
8467 }
8468
8469
8470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8471   void * jresult ;
8472   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8473   float *result = 0 ;
8474
8475   arg1 = (Dali::Vector4 *)jarg1;
8476   {
8477     try {
8478       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8479     } catch (std::out_of_range& e) {
8480       {
8481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8482       };
8483     } catch (std::exception& e) {
8484       {
8485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8486       };
8487     } catch (Dali::DaliException e) {
8488       {
8489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8490       };
8491     } catch (...) {
8492       {
8493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8494       };
8495     }
8496   }
8497
8498   jresult = (void *)result;
8499   return jresult;
8500 }
8501
8502
8503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8504   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8505   float arg2 ;
8506
8507   arg1 = (Dali::Vector4 *)jarg1;
8508   arg2 = (float)jarg2;
8509   if (arg1) (arg1)->x = arg2;
8510 }
8511
8512
8513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8514   float jresult ;
8515   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8516   float result;
8517
8518   arg1 = (Dali::Vector4 *)jarg1;
8519   result = (float) ((arg1)->x);
8520   jresult = result;
8521   return jresult;
8522 }
8523
8524
8525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8526   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8527   float arg2 ;
8528
8529   arg1 = (Dali::Vector4 *)jarg1;
8530   arg2 = (float)jarg2;
8531   if (arg1) (arg1)->r = arg2;
8532 }
8533
8534
8535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8536   float jresult ;
8537   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8538   float result;
8539
8540   arg1 = (Dali::Vector4 *)jarg1;
8541   result = (float) ((arg1)->r);
8542   jresult = result;
8543   return jresult;
8544 }
8545
8546
8547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8548   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8549   float arg2 ;
8550
8551   arg1 = (Dali::Vector4 *)jarg1;
8552   arg2 = (float)jarg2;
8553   if (arg1) (arg1)->s = arg2;
8554 }
8555
8556
8557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8558   float jresult ;
8559   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8560   float result;
8561
8562   arg1 = (Dali::Vector4 *)jarg1;
8563   result = (float) ((arg1)->s);
8564   jresult = result;
8565   return jresult;
8566 }
8567
8568
8569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8570   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8571   float arg2 ;
8572
8573   arg1 = (Dali::Vector4 *)jarg1;
8574   arg2 = (float)jarg2;
8575   if (arg1) (arg1)->y = arg2;
8576 }
8577
8578
8579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8580   float jresult ;
8581   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8582   float result;
8583
8584   arg1 = (Dali::Vector4 *)jarg1;
8585   result = (float) ((arg1)->y);
8586   jresult = result;
8587   return jresult;
8588 }
8589
8590
8591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8592   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8593   float arg2 ;
8594
8595   arg1 = (Dali::Vector4 *)jarg1;
8596   arg2 = (float)jarg2;
8597   if (arg1) (arg1)->g = arg2;
8598 }
8599
8600
8601 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8602   float jresult ;
8603   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8604   float result;
8605
8606   arg1 = (Dali::Vector4 *)jarg1;
8607   result = (float) ((arg1)->g);
8608   jresult = result;
8609   return jresult;
8610 }
8611
8612
8613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8614   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8615   float arg2 ;
8616
8617   arg1 = (Dali::Vector4 *)jarg1;
8618   arg2 = (float)jarg2;
8619   if (arg1) (arg1)->t = arg2;
8620 }
8621
8622
8623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8624   float jresult ;
8625   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8626   float result;
8627
8628   arg1 = (Dali::Vector4 *)jarg1;
8629   result = (float) ((arg1)->t);
8630   jresult = result;
8631   return jresult;
8632 }
8633
8634
8635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8636   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8637   float arg2 ;
8638
8639   arg1 = (Dali::Vector4 *)jarg1;
8640   arg2 = (float)jarg2;
8641   if (arg1) (arg1)->z = arg2;
8642 }
8643
8644
8645 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8646   float jresult ;
8647   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8648   float result;
8649
8650   arg1 = (Dali::Vector4 *)jarg1;
8651   result = (float) ((arg1)->z);
8652   jresult = result;
8653   return jresult;
8654 }
8655
8656
8657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8658   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8659   float arg2 ;
8660
8661   arg1 = (Dali::Vector4 *)jarg1;
8662   arg2 = (float)jarg2;
8663   if (arg1) (arg1)->b = arg2;
8664 }
8665
8666
8667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8668   float jresult ;
8669   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8670   float result;
8671
8672   arg1 = (Dali::Vector4 *)jarg1;
8673   result = (float) ((arg1)->b);
8674   jresult = result;
8675   return jresult;
8676 }
8677
8678
8679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8680   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8681   float arg2 ;
8682
8683   arg1 = (Dali::Vector4 *)jarg1;
8684   arg2 = (float)jarg2;
8685   if (arg1) (arg1)->p = arg2;
8686 }
8687
8688
8689 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8690   float jresult ;
8691   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8692   float result;
8693
8694   arg1 = (Dali::Vector4 *)jarg1;
8695   result = (float) ((arg1)->p);
8696   jresult = result;
8697   return jresult;
8698 }
8699
8700
8701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8702   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8703   float arg2 ;
8704
8705   arg1 = (Dali::Vector4 *)jarg1;
8706   arg2 = (float)jarg2;
8707   if (arg1) (arg1)->w = arg2;
8708 }
8709
8710
8711 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8712   float jresult ;
8713   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8714   float result;
8715
8716   arg1 = (Dali::Vector4 *)jarg1;
8717   result = (float) ((arg1)->w);
8718   jresult = result;
8719   return jresult;
8720 }
8721
8722
8723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8724   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8725   float arg2 ;
8726
8727   arg1 = (Dali::Vector4 *)jarg1;
8728   arg2 = (float)jarg2;
8729   if (arg1) (arg1)->a = arg2;
8730 }
8731
8732
8733 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8734   float jresult ;
8735   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8736   float result;
8737
8738   arg1 = (Dali::Vector4 *)jarg1;
8739   result = (float) ((arg1)->a);
8740   jresult = result;
8741   return jresult;
8742 }
8743
8744
8745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8746   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8747   float arg2 ;
8748
8749   arg1 = (Dali::Vector4 *)jarg1;
8750   arg2 = (float)jarg2;
8751   if (arg1) (arg1)->q = arg2;
8752 }
8753
8754
8755 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8756   float jresult ;
8757   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8758   float result;
8759
8760   arg1 = (Dali::Vector4 *)jarg1;
8761   result = (float) ((arg1)->q);
8762   jresult = result;
8763   return jresult;
8764 }
8765
8766
8767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8768   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8769
8770   arg1 = (Dali::Vector4 *)jarg1;
8771   {
8772     try {
8773       delete arg1;
8774     } catch (std::out_of_range& e) {
8775       {
8776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8777       };
8778     } catch (std::exception& e) {
8779       {
8780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8781       };
8782     } catch (Dali::DaliException e) {
8783       {
8784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8785       };
8786     } catch (...) {
8787       {
8788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8789       };
8790     }
8791   }
8792
8793 }
8794
8795
8796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8797   void * jresult ;
8798   Dali::Vector4 *arg1 = 0 ;
8799   Dali::Vector4 *arg2 = 0 ;
8800   Dali::Vector4 result;
8801
8802   arg1 = (Dali::Vector4 *)jarg1;
8803   if (!arg1) {
8804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8805     return 0;
8806   }
8807   arg2 = (Dali::Vector4 *)jarg2;
8808   if (!arg2) {
8809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8810     return 0;
8811   }
8812   {
8813     try {
8814       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8815     } catch (std::out_of_range& e) {
8816       {
8817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8818       };
8819     } catch (std::exception& e) {
8820       {
8821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8822       };
8823     } catch (Dali::DaliException e) {
8824       {
8825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8826       };
8827     } catch (...) {
8828       {
8829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8830       };
8831     }
8832   }
8833
8834   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8835   return jresult;
8836 }
8837
8838
8839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8840   void * jresult ;
8841   Dali::Vector4 *arg1 = 0 ;
8842   Dali::Vector4 *arg2 = 0 ;
8843   Dali::Vector4 result;
8844
8845   arg1 = (Dali::Vector4 *)jarg1;
8846   if (!arg1) {
8847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8848     return 0;
8849   }
8850   arg2 = (Dali::Vector4 *)jarg2;
8851   if (!arg2) {
8852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8853     return 0;
8854   }
8855   {
8856     try {
8857       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8858     } catch (std::out_of_range& e) {
8859       {
8860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8861       };
8862     } catch (std::exception& e) {
8863       {
8864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8865       };
8866     } catch (Dali::DaliException e) {
8867       {
8868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8869       };
8870     } catch (...) {
8871       {
8872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8873       };
8874     }
8875   }
8876
8877   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8878   return jresult;
8879 }
8880
8881
8882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8883   void * jresult ;
8884   Dali::Vector4 *arg1 = 0 ;
8885   float *arg2 = 0 ;
8886   float *arg3 = 0 ;
8887   float temp2 ;
8888   float temp3 ;
8889   Dali::Vector4 result;
8890
8891   arg1 = (Dali::Vector4 *)jarg1;
8892   if (!arg1) {
8893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8894     return 0;
8895   }
8896   temp2 = (float)jarg2;
8897   arg2 = &temp2;
8898   temp3 = (float)jarg3;
8899   arg3 = &temp3;
8900   {
8901     try {
8902       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8903     } catch (std::out_of_range& e) {
8904       {
8905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8906       };
8907     } catch (std::exception& e) {
8908       {
8909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8910       };
8911     } catch (Dali::DaliException e) {
8912       {
8913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8914       };
8915     } catch (...) {
8916       {
8917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8918       };
8919     }
8920   }
8921
8922   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8923   return jresult;
8924 }
8925
8926
8927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8928   void * jresult ;
8929   Dali::Uint16Pair *result = 0 ;
8930
8931   {
8932     try {
8933       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8934     } catch (std::out_of_range& e) {
8935       {
8936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8937       };
8938     } catch (std::exception& e) {
8939       {
8940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8941       };
8942     } catch (Dali::DaliException e) {
8943       {
8944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8945       };
8946     } catch (...) {
8947       {
8948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8949       };
8950     }
8951   }
8952
8953   jresult = (void *)result;
8954   return jresult;
8955 }
8956
8957
8958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8959   void * jresult ;
8960   uint32_t arg1 ;
8961   uint32_t arg2 ;
8962   Dali::Uint16Pair *result = 0 ;
8963
8964   arg1 = (uint32_t)jarg1;
8965   arg2 = (uint32_t)jarg2;
8966   {
8967     try {
8968       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8969     } catch (std::out_of_range& e) {
8970       {
8971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8972       };
8973     } catch (std::exception& e) {
8974       {
8975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8976       };
8977     } catch (Dali::DaliException e) {
8978       {
8979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8980       };
8981     } catch (...) {
8982       {
8983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8984       };
8985     }
8986   }
8987
8988   jresult = (void *)result;
8989   return jresult;
8990 }
8991
8992
8993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8994   void * jresult ;
8995   Dali::Uint16Pair *arg1 = 0 ;
8996   Dali::Uint16Pair *result = 0 ;
8997
8998   arg1 = (Dali::Uint16Pair *)jarg1;
8999   if (!arg1) {
9000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9001     return 0;
9002   }
9003   {
9004     try {
9005       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9006     } catch (std::out_of_range& e) {
9007       {
9008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9009       };
9010     } catch (std::exception& e) {
9011       {
9012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9013       };
9014     } catch (Dali::DaliException e) {
9015       {
9016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9017       };
9018     } catch (...) {
9019       {
9020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9021       };
9022     }
9023   }
9024
9025   jresult = (void *)result;
9026   return jresult;
9027 }
9028
9029
9030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9031   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9032   uint16_t arg2 ;
9033
9034   arg1 = (Dali::Uint16Pair *)jarg1;
9035   arg2 = (uint16_t)jarg2;
9036   {
9037     try {
9038       (arg1)->SetWidth(arg2);
9039     } catch (std::out_of_range& e) {
9040       {
9041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9042       };
9043     } catch (std::exception& e) {
9044       {
9045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9046       };
9047     } catch (Dali::DaliException e) {
9048       {
9049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9050       };
9051     } catch (...) {
9052       {
9053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9054       };
9055     }
9056   }
9057
9058 }
9059
9060
9061 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9062   unsigned short jresult ;
9063   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9064   uint16_t result;
9065
9066   arg1 = (Dali::Uint16Pair *)jarg1;
9067   {
9068     try {
9069       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9070     } catch (std::out_of_range& e) {
9071       {
9072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9073       };
9074     } catch (std::exception& e) {
9075       {
9076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9077       };
9078     } catch (Dali::DaliException e) {
9079       {
9080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9081       };
9082     } catch (...) {
9083       {
9084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9085       };
9086     }
9087   }
9088
9089   jresult = result;
9090   return jresult;
9091 }
9092
9093
9094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9095   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9096   uint16_t arg2 ;
9097
9098   arg1 = (Dali::Uint16Pair *)jarg1;
9099   arg2 = (uint16_t)jarg2;
9100   {
9101     try {
9102       (arg1)->SetHeight(arg2);
9103     } catch (std::out_of_range& e) {
9104       {
9105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9106       };
9107     } catch (std::exception& e) {
9108       {
9109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9110       };
9111     } catch (Dali::DaliException e) {
9112       {
9113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9114       };
9115     } catch (...) {
9116       {
9117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9118       };
9119     }
9120   }
9121
9122 }
9123
9124
9125 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9126   unsigned short jresult ;
9127   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9128   uint16_t result;
9129
9130   arg1 = (Dali::Uint16Pair *)jarg1;
9131   {
9132     try {
9133       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9134     } catch (std::out_of_range& e) {
9135       {
9136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9137       };
9138     } catch (std::exception& e) {
9139       {
9140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9141       };
9142     } catch (Dali::DaliException e) {
9143       {
9144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9145       };
9146     } catch (...) {
9147       {
9148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9149       };
9150     }
9151   }
9152
9153   jresult = result;
9154   return jresult;
9155 }
9156
9157
9158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9159   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9160   uint16_t arg2 ;
9161
9162   arg1 = (Dali::Uint16Pair *)jarg1;
9163   arg2 = (uint16_t)jarg2;
9164   {
9165     try {
9166       (arg1)->SetX(arg2);
9167     } catch (std::out_of_range& e) {
9168       {
9169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9170       };
9171     } catch (std::exception& e) {
9172       {
9173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9174       };
9175     } catch (Dali::DaliException e) {
9176       {
9177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9178       };
9179     } catch (...) {
9180       {
9181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9182       };
9183     }
9184   }
9185
9186 }
9187
9188
9189 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9190   unsigned short jresult ;
9191   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9192   uint16_t result;
9193
9194   arg1 = (Dali::Uint16Pair *)jarg1;
9195   {
9196     try {
9197       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9198     } catch (std::out_of_range& e) {
9199       {
9200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9201       };
9202     } catch (std::exception& e) {
9203       {
9204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9205       };
9206     } catch (Dali::DaliException e) {
9207       {
9208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9209       };
9210     } catch (...) {
9211       {
9212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9213       };
9214     }
9215   }
9216
9217   jresult = result;
9218   return jresult;
9219 }
9220
9221
9222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9223   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9224   uint16_t arg2 ;
9225
9226   arg1 = (Dali::Uint16Pair *)jarg1;
9227   arg2 = (uint16_t)jarg2;
9228   {
9229     try {
9230       (arg1)->SetY(arg2);
9231     } catch (std::out_of_range& e) {
9232       {
9233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9234       };
9235     } catch (std::exception& e) {
9236       {
9237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9238       };
9239     } catch (Dali::DaliException e) {
9240       {
9241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9242       };
9243     } catch (...) {
9244       {
9245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9246       };
9247     }
9248   }
9249
9250 }
9251
9252
9253 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9254   unsigned short jresult ;
9255   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9256   uint16_t result;
9257
9258   arg1 = (Dali::Uint16Pair *)jarg1;
9259   {
9260     try {
9261       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9262     } catch (std::out_of_range& e) {
9263       {
9264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9265       };
9266     } catch (std::exception& e) {
9267       {
9268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9269       };
9270     } catch (Dali::DaliException e) {
9271       {
9272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9273       };
9274     } catch (...) {
9275       {
9276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9277       };
9278     }
9279   }
9280
9281   jresult = result;
9282   return jresult;
9283 }
9284
9285
9286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9287   void * jresult ;
9288   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9289   Dali::Uint16Pair *arg2 = 0 ;
9290   Dali::Uint16Pair *result = 0 ;
9291
9292   arg1 = (Dali::Uint16Pair *)jarg1;
9293   arg2 = (Dali::Uint16Pair *)jarg2;
9294   if (!arg2) {
9295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9296     return 0;
9297   }
9298   {
9299     try {
9300       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9301     } catch (std::out_of_range& e) {
9302       {
9303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9304       };
9305     } catch (std::exception& e) {
9306       {
9307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9308       };
9309     } catch (Dali::DaliException e) {
9310       {
9311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9312       };
9313     } catch (...) {
9314       {
9315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9316       };
9317     }
9318   }
9319
9320   jresult = (void *)result;
9321   return jresult;
9322 }
9323
9324
9325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9326   unsigned int jresult ;
9327   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9328   Dali::Uint16Pair *arg2 = 0 ;
9329   bool result;
9330
9331   arg1 = (Dali::Uint16Pair *)jarg1;
9332   arg2 = (Dali::Uint16Pair *)jarg2;
9333   if (!arg2) {
9334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9335     return 0;
9336   }
9337   {
9338     try {
9339       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9340     } catch (std::out_of_range& e) {
9341       {
9342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9343       };
9344     } catch (std::exception& e) {
9345       {
9346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9347       };
9348     } catch (Dali::DaliException e) {
9349       {
9350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9351       };
9352     } catch (...) {
9353       {
9354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9355       };
9356     }
9357   }
9358
9359   jresult = result;
9360   return jresult;
9361 }
9362
9363
9364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9365   unsigned int jresult ;
9366   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9367   Dali::Uint16Pair *arg2 = 0 ;
9368   bool result;
9369
9370   arg1 = (Dali::Uint16Pair *)jarg1;
9371   arg2 = (Dali::Uint16Pair *)jarg2;
9372   if (!arg2) {
9373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9374     return 0;
9375   }
9376   {
9377     try {
9378       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9379     } catch (std::out_of_range& e) {
9380       {
9381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9382       };
9383     } catch (std::exception& e) {
9384       {
9385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9386       };
9387     } catch (Dali::DaliException e) {
9388       {
9389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9390       };
9391     } catch (...) {
9392       {
9393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9394       };
9395     }
9396   }
9397
9398   jresult = result;
9399   return jresult;
9400 }
9401
9402
9403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9404   unsigned int jresult ;
9405   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9406   Dali::Uint16Pair *arg2 = 0 ;
9407   bool result;
9408
9409   arg1 = (Dali::Uint16Pair *)jarg1;
9410   arg2 = (Dali::Uint16Pair *)jarg2;
9411   if (!arg2) {
9412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9413     return 0;
9414   }
9415   {
9416     try {
9417       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9418     } catch (std::out_of_range& e) {
9419       {
9420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9421       };
9422     } catch (std::exception& e) {
9423       {
9424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9425       };
9426     } catch (Dali::DaliException e) {
9427       {
9428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9429       };
9430     } catch (...) {
9431       {
9432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9433       };
9434     }
9435   }
9436
9437   jresult = result;
9438   return jresult;
9439 }
9440
9441
9442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9443   unsigned int jresult ;
9444   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9445   Dali::Uint16Pair *arg2 = 0 ;
9446   bool result;
9447
9448   arg1 = (Dali::Uint16Pair *)jarg1;
9449   arg2 = (Dali::Uint16Pair *)jarg2;
9450   if (!arg2) {
9451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9452     return 0;
9453   }
9454   {
9455     try {
9456       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9457     } catch (std::out_of_range& e) {
9458       {
9459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9460       };
9461     } catch (std::exception& e) {
9462       {
9463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9464       };
9465     } catch (Dali::DaliException e) {
9466       {
9467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9468       };
9469     } catch (...) {
9470       {
9471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9472       };
9473     }
9474   }
9475
9476   jresult = result;
9477   return jresult;
9478 }
9479
9480
9481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9482   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9483
9484   arg1 = (Dali::Uint16Pair *)jarg1;
9485   {
9486     try {
9487       delete arg1;
9488     } catch (std::out_of_range& e) {
9489       {
9490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9491       };
9492     } catch (std::exception& e) {
9493       {
9494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9495       };
9496     } catch (Dali::DaliException e) {
9497       {
9498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9499       };
9500     } catch (...) {
9501       {
9502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9503       };
9504     }
9505   }
9506
9507 }
9508
9509
9510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9511   void * jresult ;
9512   Dali::Degree *result = 0 ;
9513
9514   {
9515     try {
9516       result = (Dali::Degree *)new Dali::Degree();
9517     } catch (std::out_of_range& e) {
9518       {
9519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9520       };
9521     } catch (std::exception& e) {
9522       {
9523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9524       };
9525     } catch (Dali::DaliException e) {
9526       {
9527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9528       };
9529     } catch (...) {
9530       {
9531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9532       };
9533     }
9534   }
9535
9536   jresult = (void *)result;
9537   return jresult;
9538 }
9539
9540
9541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9542   void * jresult ;
9543   float arg1 ;
9544   Dali::Degree *result = 0 ;
9545
9546   arg1 = (float)jarg1;
9547   {
9548     try {
9549       result = (Dali::Degree *)new Dali::Degree(arg1);
9550     } catch (std::out_of_range& e) {
9551       {
9552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9553       };
9554     } catch (std::exception& e) {
9555       {
9556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9557       };
9558     } catch (Dali::DaliException e) {
9559       {
9560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9561       };
9562     } catch (...) {
9563       {
9564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9565       };
9566     }
9567   }
9568
9569   jresult = (void *)result;
9570   return jresult;
9571 }
9572
9573
9574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9575   void * jresult ;
9576   Dali::Radian arg1 ;
9577   Dali::Radian *argp1 ;
9578   Dali::Degree *result = 0 ;
9579
9580   argp1 = (Dali::Radian *)jarg1;
9581   if (!argp1) {
9582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9583     return 0;
9584   }
9585   arg1 = *argp1;
9586   {
9587     try {
9588       result = (Dali::Degree *)new Dali::Degree(arg1);
9589     } catch (std::out_of_range& e) {
9590       {
9591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9592       };
9593     } catch (std::exception& e) {
9594       {
9595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9596       };
9597     } catch (Dali::DaliException e) {
9598       {
9599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9600       };
9601     } catch (...) {
9602       {
9603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9604       };
9605     }
9606   }
9607
9608   jresult = (void *)result;
9609   return jresult;
9610 }
9611
9612
9613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9614   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9615   float arg2 ;
9616
9617   arg1 = (Dali::Degree *)jarg1;
9618   arg2 = (float)jarg2;
9619   if (arg1) (arg1)->degree = arg2;
9620 }
9621
9622
9623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9624   float jresult ;
9625   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9626   float result;
9627
9628   arg1 = (Dali::Degree *)jarg1;
9629   result = (float) ((arg1)->degree);
9630   jresult = result;
9631   return jresult;
9632 }
9633
9634
9635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9636   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9637
9638   arg1 = (Dali::Degree *)jarg1;
9639   {
9640     try {
9641       delete arg1;
9642     } catch (std::out_of_range& e) {
9643       {
9644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9645       };
9646     } catch (std::exception& e) {
9647       {
9648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9649       };
9650     } catch (Dali::DaliException e) {
9651       {
9652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9653       };
9654     } catch (...) {
9655       {
9656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9657       };
9658     }
9659   }
9660
9661 }
9662
9663
9664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9665   void * jresult ;
9666   Dali::Radian *result = 0 ;
9667
9668   result = (Dali::Radian *)&Dali::ANGLE_360;
9669   jresult = (void *)result;
9670   return jresult;
9671 }
9672
9673
9674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9675   void * jresult ;
9676   Dali::Radian *result = 0 ;
9677
9678   result = (Dali::Radian *)&Dali::ANGLE_315;
9679   jresult = (void *)result;
9680   return jresult;
9681 }
9682
9683
9684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9685   void * jresult ;
9686   Dali::Radian *result = 0 ;
9687
9688   result = (Dali::Radian *)&Dali::ANGLE_270;
9689   jresult = (void *)result;
9690   return jresult;
9691 }
9692
9693
9694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9695   void * jresult ;
9696   Dali::Radian *result = 0 ;
9697
9698   result = (Dali::Radian *)&Dali::ANGLE_225;
9699   jresult = (void *)result;
9700   return jresult;
9701 }
9702
9703
9704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9705   void * jresult ;
9706   Dali::Radian *result = 0 ;
9707
9708   result = (Dali::Radian *)&Dali::ANGLE_180;
9709   jresult = (void *)result;
9710   return jresult;
9711 }
9712
9713
9714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9715   void * jresult ;
9716   Dali::Radian *result = 0 ;
9717
9718   result = (Dali::Radian *)&Dali::ANGLE_135;
9719   jresult = (void *)result;
9720   return jresult;
9721 }
9722
9723
9724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9725   void * jresult ;
9726   Dali::Radian *result = 0 ;
9727
9728   result = (Dali::Radian *)&Dali::ANGLE_120;
9729   jresult = (void *)result;
9730   return jresult;
9731 }
9732
9733
9734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9735   void * jresult ;
9736   Dali::Radian *result = 0 ;
9737
9738   result = (Dali::Radian *)&Dali::ANGLE_90;
9739   jresult = (void *)result;
9740   return jresult;
9741 }
9742
9743
9744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9745   void * jresult ;
9746   Dali::Radian *result = 0 ;
9747
9748   result = (Dali::Radian *)&Dali::ANGLE_60;
9749   jresult = (void *)result;
9750   return jresult;
9751 }
9752
9753
9754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9755   void * jresult ;
9756   Dali::Radian *result = 0 ;
9757
9758   result = (Dali::Radian *)&Dali::ANGLE_45;
9759   jresult = (void *)result;
9760   return jresult;
9761 }
9762
9763
9764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9765   void * jresult ;
9766   Dali::Radian *result = 0 ;
9767
9768   result = (Dali::Radian *)&Dali::ANGLE_30;
9769   jresult = (void *)result;
9770   return jresult;
9771 }
9772
9773
9774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9775   void * jresult ;
9776   Dali::Radian *result = 0 ;
9777
9778   result = (Dali::Radian *)&Dali::ANGLE_0;
9779   jresult = (void *)result;
9780   return jresult;
9781 }
9782
9783
9784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9785   unsigned int jresult ;
9786   Dali::Degree *arg1 = 0 ;
9787   Dali::Degree *arg2 = 0 ;
9788   bool result;
9789
9790   arg1 = (Dali::Degree *)jarg1;
9791   if (!arg1) {
9792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9793     return 0;
9794   }
9795   arg2 = (Dali::Degree *)jarg2;
9796   if (!arg2) {
9797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9798     return 0;
9799   }
9800   {
9801     try {
9802       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9803     } catch (std::out_of_range& e) {
9804       {
9805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9806       };
9807     } catch (std::exception& e) {
9808       {
9809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9810       };
9811     } catch (Dali::DaliException e) {
9812       {
9813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9814       };
9815     } catch (...) {
9816       {
9817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9818       };
9819     }
9820   }
9821
9822   jresult = result;
9823   return jresult;
9824 }
9825
9826
9827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9828   unsigned int jresult ;
9829   Dali::Degree *arg1 = 0 ;
9830   Dali::Degree *arg2 = 0 ;
9831   bool result;
9832
9833   arg1 = (Dali::Degree *)jarg1;
9834   if (!arg1) {
9835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9836     return 0;
9837   }
9838   arg2 = (Dali::Degree *)jarg2;
9839   if (!arg2) {
9840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9841     return 0;
9842   }
9843   {
9844     try {
9845       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9846     } catch (std::out_of_range& e) {
9847       {
9848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9849       };
9850     } catch (std::exception& e) {
9851       {
9852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9853       };
9854     } catch (Dali::DaliException e) {
9855       {
9856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9857       };
9858     } catch (...) {
9859       {
9860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9861       };
9862     }
9863   }
9864
9865   jresult = result;
9866   return jresult;
9867 }
9868
9869
9870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9871   void * jresult ;
9872   Dali::Degree arg1 ;
9873   float arg2 ;
9874   float arg3 ;
9875   Dali::Degree *argp1 ;
9876   Dali::Degree result;
9877
9878   argp1 = (Dali::Degree *)jarg1;
9879   if (!argp1) {
9880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9881     return 0;
9882   }
9883   arg1 = *argp1;
9884   arg2 = (float)jarg2;
9885   arg3 = (float)jarg3;
9886   {
9887     try {
9888       result = Dali::Clamp(arg1,arg2,arg3);
9889     } catch (std::out_of_range& e) {
9890       {
9891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9892       };
9893     } catch (std::exception& e) {
9894       {
9895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9896       };
9897     } catch (Dali::DaliException e) {
9898       {
9899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9900       };
9901     } catch (...) {
9902       {
9903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9904       };
9905     }
9906   }
9907
9908   jresult = new Dali::Degree((const Dali::Degree &)result);
9909   return jresult;
9910 }
9911
9912
9913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9914   void * jresult ;
9915   Dali::Radian *result = 0 ;
9916
9917   {
9918     try {
9919       result = (Dali::Radian *)new Dali::Radian();
9920     } catch (std::out_of_range& e) {
9921       {
9922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9923       };
9924     } catch (std::exception& e) {
9925       {
9926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9927       };
9928     } catch (Dali::DaliException e) {
9929       {
9930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9931       };
9932     } catch (...) {
9933       {
9934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9935       };
9936     }
9937   }
9938
9939   jresult = (void *)result;
9940   return jresult;
9941 }
9942
9943
9944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9945   void * jresult ;
9946   float arg1 ;
9947   Dali::Radian *result = 0 ;
9948
9949   arg1 = (float)jarg1;
9950   {
9951     try {
9952       result = (Dali::Radian *)new Dali::Radian(arg1);
9953     } catch (std::out_of_range& e) {
9954       {
9955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9956       };
9957     } catch (std::exception& e) {
9958       {
9959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9960       };
9961     } catch (Dali::DaliException e) {
9962       {
9963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9964       };
9965     } catch (...) {
9966       {
9967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9968       };
9969     }
9970   }
9971
9972   jresult = (void *)result;
9973   return jresult;
9974 }
9975
9976
9977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9978   void * jresult ;
9979   Dali::Degree arg1 ;
9980   Dali::Degree *argp1 ;
9981   Dali::Radian *result = 0 ;
9982
9983   argp1 = (Dali::Degree *)jarg1;
9984   if (!argp1) {
9985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9986     return 0;
9987   }
9988   arg1 = *argp1;
9989   {
9990     try {
9991       result = (Dali::Radian *)new Dali::Radian(arg1);
9992     } catch (std::out_of_range& e) {
9993       {
9994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9995       };
9996     } catch (std::exception& e) {
9997       {
9998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9999       };
10000     } catch (Dali::DaliException e) {
10001       {
10002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10003       };
10004     } catch (...) {
10005       {
10006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10007       };
10008     }
10009   }
10010
10011   jresult = (void *)result;
10012   return jresult;
10013 }
10014
10015
10016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10017   void * jresult ;
10018   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10019   float arg2 ;
10020   Dali::Radian *result = 0 ;
10021
10022   arg1 = (Dali::Radian *)jarg1;
10023   arg2 = (float)jarg2;
10024   {
10025     try {
10026       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10027     } catch (std::out_of_range& e) {
10028       {
10029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10030       };
10031     } catch (std::exception& e) {
10032       {
10033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10034       };
10035     } catch (Dali::DaliException e) {
10036       {
10037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10038       };
10039     } catch (...) {
10040       {
10041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10042       };
10043     }
10044   }
10045
10046   jresult = (void *)result;
10047   return jresult;
10048 }
10049
10050
10051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10052   void * jresult ;
10053   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10054   Dali::Degree arg2 ;
10055   Dali::Degree *argp2 ;
10056   Dali::Radian *result = 0 ;
10057
10058   arg1 = (Dali::Radian *)jarg1;
10059   argp2 = (Dali::Degree *)jarg2;
10060   if (!argp2) {
10061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10062     return 0;
10063   }
10064   arg2 = *argp2;
10065   {
10066     try {
10067       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10068     } catch (std::out_of_range& e) {
10069       {
10070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10071       };
10072     } catch (std::exception& e) {
10073       {
10074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10075       };
10076     } catch (Dali::DaliException e) {
10077       {
10078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10079       };
10080     } catch (...) {
10081       {
10082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10083       };
10084     }
10085   }
10086
10087   jresult = (void *)result;
10088   return jresult;
10089 }
10090
10091
10092 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10093   float jresult ;
10094   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10095   float result;
10096
10097   arg1 = (Dali::Radian *)jarg1;
10098   {
10099     try {
10100       result = (float)((Dali::Radian const *)arg1)->operator float();
10101     } catch (std::out_of_range& e) {
10102       {
10103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10104       };
10105     } catch (std::exception& e) {
10106       {
10107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10108       };
10109     } catch (Dali::DaliException e) {
10110       {
10111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10112       };
10113     } catch (...) {
10114       {
10115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10116       };
10117     }
10118   }
10119
10120   jresult = result;
10121   return jresult;
10122 }
10123
10124
10125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10126   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10127   float arg2 ;
10128
10129   arg1 = (Dali::Radian *)jarg1;
10130   arg2 = (float)jarg2;
10131   if (arg1) (arg1)->radian = arg2;
10132 }
10133
10134
10135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10136   float jresult ;
10137   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10138   float result;
10139
10140   arg1 = (Dali::Radian *)jarg1;
10141   result = (float) ((arg1)->radian);
10142   jresult = result;
10143   return jresult;
10144 }
10145
10146
10147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10148   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10149
10150   arg1 = (Dali::Radian *)jarg1;
10151   {
10152     try {
10153       delete arg1;
10154     } catch (std::out_of_range& e) {
10155       {
10156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10157       };
10158     } catch (std::exception& e) {
10159       {
10160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10161       };
10162     } catch (Dali::DaliException e) {
10163       {
10164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10165       };
10166     } catch (...) {
10167       {
10168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10169       };
10170     }
10171   }
10172
10173 }
10174
10175
10176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10177   unsigned int jresult ;
10178   Dali::Radian arg1 ;
10179   Dali::Radian arg2 ;
10180   Dali::Radian *argp1 ;
10181   Dali::Radian *argp2 ;
10182   bool result;
10183
10184   argp1 = (Dali::Radian *)jarg1;
10185   if (!argp1) {
10186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10187     return 0;
10188   }
10189   arg1 = *argp1;
10190   argp2 = (Dali::Radian *)jarg2;
10191   if (!argp2) {
10192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10193     return 0;
10194   }
10195   arg2 = *argp2;
10196   {
10197     try {
10198       result = (bool)Dali::operator ==(arg1,arg2);
10199     } catch (std::out_of_range& e) {
10200       {
10201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10202       };
10203     } catch (std::exception& e) {
10204       {
10205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10206       };
10207     } catch (Dali::DaliException e) {
10208       {
10209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10210       };
10211     } catch (...) {
10212       {
10213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10214       };
10215     }
10216   }
10217
10218   jresult = result;
10219   return jresult;
10220 }
10221
10222
10223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10224   unsigned int jresult ;
10225   Dali::Radian arg1 ;
10226   Dali::Radian arg2 ;
10227   Dali::Radian *argp1 ;
10228   Dali::Radian *argp2 ;
10229   bool result;
10230
10231   argp1 = (Dali::Radian *)jarg1;
10232   if (!argp1) {
10233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10234     return 0;
10235   }
10236   arg1 = *argp1;
10237   argp2 = (Dali::Radian *)jarg2;
10238   if (!argp2) {
10239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10240     return 0;
10241   }
10242   arg2 = *argp2;
10243   {
10244     try {
10245       result = (bool)Dali::operator !=(arg1,arg2);
10246     } catch (std::out_of_range& e) {
10247       {
10248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10249       };
10250     } catch (std::exception& e) {
10251       {
10252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10253       };
10254     } catch (Dali::DaliException e) {
10255       {
10256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10257       };
10258     } catch (...) {
10259       {
10260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10261       };
10262     }
10263   }
10264
10265   jresult = result;
10266   return jresult;
10267 }
10268
10269
10270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10271   unsigned int jresult ;
10272   Dali::Radian arg1 ;
10273   Dali::Degree arg2 ;
10274   Dali::Radian *argp1 ;
10275   Dali::Degree *argp2 ;
10276   bool result;
10277
10278   argp1 = (Dali::Radian *)jarg1;
10279   if (!argp1) {
10280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10281     return 0;
10282   }
10283   arg1 = *argp1;
10284   argp2 = (Dali::Degree *)jarg2;
10285   if (!argp2) {
10286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10287     return 0;
10288   }
10289   arg2 = *argp2;
10290   {
10291     try {
10292       result = (bool)Dali::operator ==(arg1,arg2);
10293     } catch (std::out_of_range& e) {
10294       {
10295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10296       };
10297     } catch (std::exception& e) {
10298       {
10299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10300       };
10301     } catch (Dali::DaliException e) {
10302       {
10303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10304       };
10305     } catch (...) {
10306       {
10307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10308       };
10309     }
10310   }
10311
10312   jresult = result;
10313   return jresult;
10314 }
10315
10316
10317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10318   unsigned int jresult ;
10319   Dali::Radian arg1 ;
10320   Dali::Degree arg2 ;
10321   Dali::Radian *argp1 ;
10322   Dali::Degree *argp2 ;
10323   bool result;
10324
10325   argp1 = (Dali::Radian *)jarg1;
10326   if (!argp1) {
10327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10328     return 0;
10329   }
10330   arg1 = *argp1;
10331   argp2 = (Dali::Degree *)jarg2;
10332   if (!argp2) {
10333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10334     return 0;
10335   }
10336   arg2 = *argp2;
10337   {
10338     try {
10339       result = (bool)Dali::operator !=(arg1,arg2);
10340     } catch (std::out_of_range& e) {
10341       {
10342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10343       };
10344     } catch (std::exception& e) {
10345       {
10346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10347       };
10348     } catch (Dali::DaliException e) {
10349       {
10350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10351       };
10352     } catch (...) {
10353       {
10354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10355       };
10356     }
10357   }
10358
10359   jresult = result;
10360   return jresult;
10361 }
10362
10363
10364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10365   unsigned int jresult ;
10366   Dali::Degree arg1 ;
10367   Dali::Radian arg2 ;
10368   Dali::Degree *argp1 ;
10369   Dali::Radian *argp2 ;
10370   bool result;
10371
10372   argp1 = (Dali::Degree *)jarg1;
10373   if (!argp1) {
10374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10375     return 0;
10376   }
10377   arg1 = *argp1;
10378   argp2 = (Dali::Radian *)jarg2;
10379   if (!argp2) {
10380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10381     return 0;
10382   }
10383   arg2 = *argp2;
10384   {
10385     try {
10386       result = (bool)Dali::operator ==(arg1,arg2);
10387     } catch (std::out_of_range& e) {
10388       {
10389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10390       };
10391     } catch (std::exception& e) {
10392       {
10393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10394       };
10395     } catch (Dali::DaliException e) {
10396       {
10397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10398       };
10399     } catch (...) {
10400       {
10401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10402       };
10403     }
10404   }
10405
10406   jresult = result;
10407   return jresult;
10408 }
10409
10410
10411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10412   unsigned int jresult ;
10413   Dali::Degree arg1 ;
10414   Dali::Radian arg2 ;
10415   Dali::Degree *argp1 ;
10416   Dali::Radian *argp2 ;
10417   bool result;
10418
10419   argp1 = (Dali::Degree *)jarg1;
10420   if (!argp1) {
10421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10422     return 0;
10423   }
10424   arg1 = *argp1;
10425   argp2 = (Dali::Radian *)jarg2;
10426   if (!argp2) {
10427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10428     return 0;
10429   }
10430   arg2 = *argp2;
10431   {
10432     try {
10433       result = (bool)Dali::operator !=(arg1,arg2);
10434     } catch (std::out_of_range& e) {
10435       {
10436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10437       };
10438     } catch (std::exception& e) {
10439       {
10440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10441       };
10442     } catch (Dali::DaliException e) {
10443       {
10444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10445       };
10446     } catch (...) {
10447       {
10448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10449       };
10450     }
10451   }
10452
10453   jresult = result;
10454   return jresult;
10455 }
10456
10457
10458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10459   unsigned int jresult ;
10460   Dali::Radian arg1 ;
10461   Dali::Radian arg2 ;
10462   Dali::Radian *argp1 ;
10463   Dali::Radian *argp2 ;
10464   bool result;
10465
10466   argp1 = (Dali::Radian *)jarg1;
10467   if (!argp1) {
10468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10469     return 0;
10470   }
10471   arg1 = *argp1;
10472   argp2 = (Dali::Radian *)jarg2;
10473   if (!argp2) {
10474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10475     return 0;
10476   }
10477   arg2 = *argp2;
10478   {
10479     try {
10480       result = (bool)Dali::operator >(arg1,arg2);
10481     } catch (std::out_of_range& e) {
10482       {
10483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10484       };
10485     } catch (std::exception& e) {
10486       {
10487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10488       };
10489     } catch (Dali::DaliException e) {
10490       {
10491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10492       };
10493     } catch (...) {
10494       {
10495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10496       };
10497     }
10498   }
10499
10500   jresult = result;
10501   return jresult;
10502 }
10503
10504
10505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10506   unsigned int jresult ;
10507   Dali::Radian arg1 ;
10508   Dali::Degree arg2 ;
10509   Dali::Radian *argp1 ;
10510   Dali::Degree *argp2 ;
10511   bool result;
10512
10513   argp1 = (Dali::Radian *)jarg1;
10514   if (!argp1) {
10515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10516     return 0;
10517   }
10518   arg1 = *argp1;
10519   argp2 = (Dali::Degree *)jarg2;
10520   if (!argp2) {
10521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10522     return 0;
10523   }
10524   arg2 = *argp2;
10525   {
10526     try {
10527       result = (bool)Dali::operator >(arg1,arg2);
10528     } catch (std::out_of_range& e) {
10529       {
10530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10531       };
10532     } catch (std::exception& e) {
10533       {
10534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10535       };
10536     } catch (Dali::DaliException e) {
10537       {
10538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10539       };
10540     } catch (...) {
10541       {
10542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10543       };
10544     }
10545   }
10546
10547   jresult = result;
10548   return jresult;
10549 }
10550
10551
10552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10553   unsigned int jresult ;
10554   Dali::Degree arg1 ;
10555   Dali::Radian arg2 ;
10556   Dali::Degree *argp1 ;
10557   Dali::Radian *argp2 ;
10558   bool result;
10559
10560   argp1 = (Dali::Degree *)jarg1;
10561   if (!argp1) {
10562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10563     return 0;
10564   }
10565   arg1 = *argp1;
10566   argp2 = (Dali::Radian *)jarg2;
10567   if (!argp2) {
10568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10569     return 0;
10570   }
10571   arg2 = *argp2;
10572   {
10573     try {
10574       result = (bool)Dali::operator >(arg1,arg2);
10575     } catch (std::out_of_range& e) {
10576       {
10577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10578       };
10579     } catch (std::exception& e) {
10580       {
10581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10582       };
10583     } catch (Dali::DaliException e) {
10584       {
10585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10586       };
10587     } catch (...) {
10588       {
10589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10590       };
10591     }
10592   }
10593
10594   jresult = result;
10595   return jresult;
10596 }
10597
10598
10599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10600   unsigned int jresult ;
10601   Dali::Radian arg1 ;
10602   Dali::Radian arg2 ;
10603   Dali::Radian *argp1 ;
10604   Dali::Radian *argp2 ;
10605   bool result;
10606
10607   argp1 = (Dali::Radian *)jarg1;
10608   if (!argp1) {
10609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10610     return 0;
10611   }
10612   arg1 = *argp1;
10613   argp2 = (Dali::Radian *)jarg2;
10614   if (!argp2) {
10615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10616     return 0;
10617   }
10618   arg2 = *argp2;
10619   {
10620     try {
10621       result = (bool)Dali::operator <(arg1,arg2);
10622     } catch (std::out_of_range& e) {
10623       {
10624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10625       };
10626     } catch (std::exception& e) {
10627       {
10628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10629       };
10630     } catch (Dali::DaliException e) {
10631       {
10632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10633       };
10634     } catch (...) {
10635       {
10636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10637       };
10638     }
10639   }
10640
10641   jresult = result;
10642   return jresult;
10643 }
10644
10645
10646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10647   unsigned int jresult ;
10648   Dali::Radian arg1 ;
10649   Dali::Degree arg2 ;
10650   Dali::Radian *argp1 ;
10651   Dali::Degree *argp2 ;
10652   bool result;
10653
10654   argp1 = (Dali::Radian *)jarg1;
10655   if (!argp1) {
10656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10657     return 0;
10658   }
10659   arg1 = *argp1;
10660   argp2 = (Dali::Degree *)jarg2;
10661   if (!argp2) {
10662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10663     return 0;
10664   }
10665   arg2 = *argp2;
10666   {
10667     try {
10668       result = (bool)Dali::operator <(arg1,arg2);
10669     } catch (std::out_of_range& e) {
10670       {
10671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10672       };
10673     } catch (std::exception& e) {
10674       {
10675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10676       };
10677     } catch (Dali::DaliException e) {
10678       {
10679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10680       };
10681     } catch (...) {
10682       {
10683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10684       };
10685     }
10686   }
10687
10688   jresult = result;
10689   return jresult;
10690 }
10691
10692
10693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10694   unsigned int jresult ;
10695   Dali::Degree arg1 ;
10696   Dali::Radian arg2 ;
10697   Dali::Degree *argp1 ;
10698   Dali::Radian *argp2 ;
10699   bool result;
10700
10701   argp1 = (Dali::Degree *)jarg1;
10702   if (!argp1) {
10703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10704     return 0;
10705   }
10706   arg1 = *argp1;
10707   argp2 = (Dali::Radian *)jarg2;
10708   if (!argp2) {
10709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10710     return 0;
10711   }
10712   arg2 = *argp2;
10713   {
10714     try {
10715       result = (bool)Dali::operator <(arg1,arg2);
10716     } catch (std::out_of_range& e) {
10717       {
10718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10719       };
10720     } catch (std::exception& e) {
10721       {
10722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10723       };
10724     } catch (Dali::DaliException e) {
10725       {
10726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10727       };
10728     } catch (...) {
10729       {
10730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10731       };
10732     }
10733   }
10734
10735   jresult = result;
10736   return jresult;
10737 }
10738
10739
10740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10741   void * jresult ;
10742   Dali::Radian arg1 ;
10743   float arg2 ;
10744   Dali::Radian *argp1 ;
10745   Dali::Radian result;
10746
10747   argp1 = (Dali::Radian *)jarg1;
10748   if (!argp1) {
10749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10750     return 0;
10751   }
10752   arg1 = *argp1;
10753   arg2 = (float)jarg2;
10754   {
10755     try {
10756       result = Dali::operator *(arg1,arg2);
10757     } catch (std::out_of_range& e) {
10758       {
10759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10760       };
10761     } catch (std::exception& e) {
10762       {
10763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10764       };
10765     } catch (Dali::DaliException e) {
10766       {
10767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10768       };
10769     } catch (...) {
10770       {
10771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10772       };
10773     }
10774   }
10775
10776   jresult = new Dali::Radian((const Dali::Radian &)result);
10777   return jresult;
10778 }
10779
10780
10781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10782   void * jresult ;
10783   Dali::Radian arg1 ;
10784   Dali::Radian *argp1 ;
10785   Dali::Radian result;
10786
10787   argp1 = (Dali::Radian *)jarg1;
10788   if (!argp1) {
10789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10790     return 0;
10791   }
10792   arg1 = *argp1;
10793   {
10794     try {
10795       result = Dali::operator -(arg1);
10796     } catch (std::out_of_range& e) {
10797       {
10798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10799       };
10800     } catch (std::exception& e) {
10801       {
10802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10803       };
10804     } catch (Dali::DaliException e) {
10805       {
10806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10807       };
10808     } catch (...) {
10809       {
10810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10811       };
10812     }
10813   }
10814
10815   jresult = new Dali::Radian((const Dali::Radian &)result);
10816   return jresult;
10817 }
10818
10819
10820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10821   void * jresult ;
10822   Dali::Radian arg1 ;
10823   float arg2 ;
10824   float arg3 ;
10825   Dali::Radian *argp1 ;
10826   Dali::Radian result;
10827
10828   argp1 = (Dali::Radian *)jarg1;
10829   if (!argp1) {
10830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10831     return 0;
10832   }
10833   arg1 = *argp1;
10834   arg2 = (float)jarg2;
10835   arg3 = (float)jarg3;
10836   {
10837     try {
10838       result = Dali::Clamp(arg1,arg2,arg3);
10839     } catch (std::out_of_range& e) {
10840       {
10841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10842       };
10843     } catch (std::exception& e) {
10844       {
10845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10846       };
10847     } catch (Dali::DaliException e) {
10848       {
10849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10850       };
10851     } catch (...) {
10852       {
10853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10854       };
10855     }
10856   }
10857
10858   jresult = new Dali::Radian((const Dali::Radian &)result);
10859   return jresult;
10860 }
10861
10862
10863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10864   void * jresult ;
10865   Dali::Quaternion *result = 0 ;
10866
10867   {
10868     try {
10869       result = (Dali::Quaternion *)new Dali::Quaternion();
10870     } catch (std::out_of_range& e) {
10871       {
10872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10873       };
10874     } catch (std::exception& e) {
10875       {
10876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10877       };
10878     } catch (Dali::DaliException e) {
10879       {
10880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10881       };
10882     } catch (...) {
10883       {
10884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10885       };
10886     }
10887   }
10888
10889   jresult = (void *)result;
10890   return jresult;
10891 }
10892
10893
10894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10895   void * jresult ;
10896   Dali::Radian arg1 ;
10897   Dali::Vector3 *arg2 = 0 ;
10898   Dali::Radian *argp1 ;
10899   Dali::Quaternion *result = 0 ;
10900
10901   argp1 = (Dali::Radian *)jarg1;
10902   if (!argp1) {
10903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10904     return 0;
10905   }
10906   arg1 = *argp1;
10907   arg2 = (Dali::Vector3 *)jarg2;
10908   if (!arg2) {
10909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10910     return 0;
10911   }
10912   {
10913     try {
10914       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10915     } catch (std::out_of_range& e) {
10916       {
10917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10918       };
10919     } catch (std::exception& e) {
10920       {
10921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10922       };
10923     } catch (Dali::DaliException e) {
10924       {
10925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10926       };
10927     } catch (...) {
10928       {
10929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10930       };
10931     }
10932   }
10933
10934   jresult = (void *)result;
10935   return jresult;
10936 }
10937
10938
10939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10940   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10941
10942   arg1 = (Dali::Quaternion *)jarg1;
10943   {
10944     try {
10945       delete arg1;
10946     } catch (std::out_of_range& e) {
10947       {
10948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10949       };
10950     } catch (std::exception& e) {
10951       {
10952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10953       };
10954     } catch (Dali::DaliException e) {
10955       {
10956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10957       };
10958     } catch (...) {
10959       {
10960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10961       };
10962     }
10963   }
10964
10965 }
10966
10967
10968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10969   void * jresult ;
10970   Dali::Quaternion *result = 0 ;
10971
10972   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
10973   jresult = (void *)result;
10974   return jresult;
10975 }
10976
10977
10978 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
10979   unsigned int jresult ;
10980   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10981   bool result;
10982
10983   arg1 = (Dali::Quaternion *)jarg1;
10984   {
10985     try {
10986       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
10987     } catch (std::out_of_range& e) {
10988       {
10989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10990       };
10991     } catch (std::exception& e) {
10992       {
10993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10994       };
10995     } catch (Dali::DaliException e) {
10996       {
10997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10998       };
10999     } catch (...) {
11000       {
11001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11002       };
11003     }
11004   }
11005
11006   jresult = result;
11007   return jresult;
11008 }
11009
11010
11011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11012   unsigned int jresult ;
11013   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11014   Dali::Vector3 *arg2 = 0 ;
11015   Dali::Radian *arg3 = 0 ;
11016   bool result;
11017
11018   arg1 = (Dali::Quaternion *)jarg1;
11019   arg2 = (Dali::Vector3 *)jarg2;
11020   if (!arg2) {
11021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11022     return 0;
11023   }
11024   arg3 = (Dali::Radian *)jarg3;
11025   if (!arg3) {
11026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11027     return 0;
11028   }
11029   {
11030     try {
11031       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11032     } catch (std::out_of_range& e) {
11033       {
11034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11035       };
11036     } catch (std::exception& e) {
11037       {
11038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11039       };
11040     } catch (Dali::DaliException e) {
11041       {
11042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11043       };
11044     } catch (...) {
11045       {
11046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11047       };
11048     }
11049   }
11050
11051   jresult = result;
11052   return jresult;
11053 }
11054
11055
11056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11057   void * jresult ;
11058   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11059   Dali::Quaternion *arg2 = 0 ;
11060   Dali::Quaternion result;
11061
11062   arg1 = (Dali::Quaternion *)jarg1;
11063   arg2 = (Dali::Quaternion *)jarg2;
11064   if (!arg2) {
11065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11066     return 0;
11067   }
11068   {
11069     try {
11070       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11071     } catch (std::out_of_range& e) {
11072       {
11073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11074       };
11075     } catch (std::exception& e) {
11076       {
11077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11078       };
11079     } catch (Dali::DaliException e) {
11080       {
11081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11082       };
11083     } catch (...) {
11084       {
11085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11086       };
11087     }
11088   }
11089
11090   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11091   return jresult;
11092 }
11093
11094
11095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11096   void * jresult ;
11097   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11098   Dali::Quaternion *arg2 = 0 ;
11099   Dali::Quaternion result;
11100
11101   arg1 = (Dali::Quaternion *)jarg1;
11102   arg2 = (Dali::Quaternion *)jarg2;
11103   if (!arg2) {
11104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11105     return 0;
11106   }
11107   {
11108     try {
11109       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11110     } catch (std::out_of_range& e) {
11111       {
11112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11113       };
11114     } catch (std::exception& e) {
11115       {
11116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11117       };
11118     } catch (Dali::DaliException e) {
11119       {
11120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11121       };
11122     } catch (...) {
11123       {
11124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11125       };
11126     }
11127   }
11128
11129   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11130   return jresult;
11131 }
11132
11133
11134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11135   void * jresult ;
11136   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11137   Dali::Quaternion *arg2 = 0 ;
11138   Dali::Quaternion result;
11139
11140   arg1 = (Dali::Quaternion *)jarg1;
11141   arg2 = (Dali::Quaternion *)jarg2;
11142   if (!arg2) {
11143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11144     return 0;
11145   }
11146   {
11147     try {
11148       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11149     } catch (std::out_of_range& e) {
11150       {
11151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11152       };
11153     } catch (std::exception& e) {
11154       {
11155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11156       };
11157     } catch (Dali::DaliException e) {
11158       {
11159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11160       };
11161     } catch (...) {
11162       {
11163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11164       };
11165     }
11166   }
11167
11168   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11169   return jresult;
11170 }
11171
11172
11173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11174   void * jresult ;
11175   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11176   Dali::Vector3 *arg2 = 0 ;
11177   Dali::Vector3 result;
11178
11179   arg1 = (Dali::Quaternion *)jarg1;
11180   arg2 = (Dali::Vector3 *)jarg2;
11181   if (!arg2) {
11182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11183     return 0;
11184   }
11185   {
11186     try {
11187       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11188     } catch (std::out_of_range& e) {
11189       {
11190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11191       };
11192     } catch (std::exception& e) {
11193       {
11194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11195       };
11196     } catch (Dali::DaliException e) {
11197       {
11198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11199       };
11200     } catch (...) {
11201       {
11202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11203       };
11204     }
11205   }
11206
11207   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11208   return jresult;
11209 }
11210
11211
11212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11213   void * jresult ;
11214   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11215   Dali::Quaternion *arg2 = 0 ;
11216   Dali::Quaternion result;
11217
11218   arg1 = (Dali::Quaternion *)jarg1;
11219   arg2 = (Dali::Quaternion *)jarg2;
11220   if (!arg2) {
11221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11222     return 0;
11223   }
11224   {
11225     try {
11226       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11227     } catch (std::out_of_range& e) {
11228       {
11229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11230       };
11231     } catch (std::exception& e) {
11232       {
11233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11234       };
11235     } catch (Dali::DaliException e) {
11236       {
11237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11238       };
11239     } catch (...) {
11240       {
11241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11242       };
11243     }
11244   }
11245
11246   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11247   return jresult;
11248 }
11249
11250
11251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11252   void * jresult ;
11253   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11254   float arg2 ;
11255   Dali::Quaternion result;
11256
11257   arg1 = (Dali::Quaternion *)jarg1;
11258   arg2 = (float)jarg2;
11259   {
11260     try {
11261       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11262     } catch (std::out_of_range& e) {
11263       {
11264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11265       };
11266     } catch (std::exception& e) {
11267       {
11268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11269       };
11270     } catch (Dali::DaliException e) {
11271       {
11272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11273       };
11274     } catch (...) {
11275       {
11276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11277       };
11278     }
11279   }
11280
11281   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11282   return jresult;
11283 }
11284
11285
11286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11287   void * jresult ;
11288   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11289   float arg2 ;
11290   Dali::Quaternion result;
11291
11292   arg1 = (Dali::Quaternion *)jarg1;
11293   arg2 = (float)jarg2;
11294   {
11295     try {
11296       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11297     } catch (std::out_of_range& e) {
11298       {
11299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11300       };
11301     } catch (std::exception& e) {
11302       {
11303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11304       };
11305     } catch (Dali::DaliException e) {
11306       {
11307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11308       };
11309     } catch (...) {
11310       {
11311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11312       };
11313     }
11314   }
11315
11316   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11317   return jresult;
11318 }
11319
11320
11321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11322   void * jresult ;
11323   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11324   Dali::Quaternion result;
11325
11326   arg1 = (Dali::Quaternion *)jarg1;
11327   {
11328     try {
11329       result = ((Dali::Quaternion const *)arg1)->operator -();
11330     } catch (std::out_of_range& e) {
11331       {
11332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11333       };
11334     } catch (std::exception& e) {
11335       {
11336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11337       };
11338     } catch (Dali::DaliException e) {
11339       {
11340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11341       };
11342     } catch (...) {
11343       {
11344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11345       };
11346     }
11347   }
11348
11349   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11350   return jresult;
11351 }
11352
11353
11354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11355   void * jresult ;
11356   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11357   Dali::Quaternion *arg2 = 0 ;
11358   Dali::Quaternion *result = 0 ;
11359
11360   arg1 = (Dali::Quaternion *)jarg1;
11361   arg2 = (Dali::Quaternion *)jarg2;
11362   if (!arg2) {
11363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11364     return 0;
11365   }
11366   {
11367     try {
11368       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11369     } catch (std::out_of_range& e) {
11370       {
11371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11372       };
11373     } catch (std::exception& e) {
11374       {
11375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11376       };
11377     } catch (Dali::DaliException e) {
11378       {
11379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11380       };
11381     } catch (...) {
11382       {
11383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11384       };
11385     }
11386   }
11387
11388   jresult = (void *)result;
11389   return jresult;
11390 }
11391
11392
11393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11394   void * jresult ;
11395   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11396   Dali::Quaternion *arg2 = 0 ;
11397   Dali::Quaternion *result = 0 ;
11398
11399   arg1 = (Dali::Quaternion *)jarg1;
11400   arg2 = (Dali::Quaternion *)jarg2;
11401   if (!arg2) {
11402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11403     return 0;
11404   }
11405   {
11406     try {
11407       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11408     } catch (std::out_of_range& e) {
11409       {
11410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11411       };
11412     } catch (std::exception& e) {
11413       {
11414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11415       };
11416     } catch (Dali::DaliException e) {
11417       {
11418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11419       };
11420     } catch (...) {
11421       {
11422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11423       };
11424     }
11425   }
11426
11427   jresult = (void *)result;
11428   return jresult;
11429 }
11430
11431
11432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11433   void * jresult ;
11434   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11435   Dali::Quaternion *arg2 = 0 ;
11436   Dali::Quaternion *result = 0 ;
11437
11438   arg1 = (Dali::Quaternion *)jarg1;
11439   arg2 = (Dali::Quaternion *)jarg2;
11440   if (!arg2) {
11441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11442     return 0;
11443   }
11444   {
11445     try {
11446       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11447     } catch (std::out_of_range& e) {
11448       {
11449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11450       };
11451     } catch (std::exception& e) {
11452       {
11453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11454       };
11455     } catch (Dali::DaliException e) {
11456       {
11457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11458       };
11459     } catch (...) {
11460       {
11461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11462       };
11463     }
11464   }
11465
11466   jresult = (void *)result;
11467   return jresult;
11468 }
11469
11470
11471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11472   void * jresult ;
11473   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11474   float arg2 ;
11475   Dali::Quaternion *result = 0 ;
11476
11477   arg1 = (Dali::Quaternion *)jarg1;
11478   arg2 = (float)jarg2;
11479   {
11480     try {
11481       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11482     } catch (std::out_of_range& e) {
11483       {
11484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11485       };
11486     } catch (std::exception& e) {
11487       {
11488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11489       };
11490     } catch (Dali::DaliException e) {
11491       {
11492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11493       };
11494     } catch (...) {
11495       {
11496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11497       };
11498     }
11499   }
11500
11501   jresult = (void *)result;
11502   return jresult;
11503 }
11504
11505
11506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11507   void * jresult ;
11508   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11509   float arg2 ;
11510   Dali::Quaternion *result = 0 ;
11511
11512   arg1 = (Dali::Quaternion *)jarg1;
11513   arg2 = (float)jarg2;
11514   {
11515     try {
11516       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11517     } catch (std::out_of_range& e) {
11518       {
11519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11520       };
11521     } catch (std::exception& e) {
11522       {
11523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11524       };
11525     } catch (Dali::DaliException e) {
11526       {
11527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11528       };
11529     } catch (...) {
11530       {
11531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11532       };
11533     }
11534   }
11535
11536   jresult = (void *)result;
11537   return jresult;
11538 }
11539
11540
11541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11542   unsigned int jresult ;
11543   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11544   Dali::Quaternion *arg2 = 0 ;
11545   bool result;
11546
11547   arg1 = (Dali::Quaternion *)jarg1;
11548   arg2 = (Dali::Quaternion *)jarg2;
11549   if (!arg2) {
11550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11551     return 0;
11552   }
11553   {
11554     try {
11555       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11556     } catch (std::out_of_range& e) {
11557       {
11558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11559       };
11560     } catch (std::exception& e) {
11561       {
11562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11563       };
11564     } catch (Dali::DaliException e) {
11565       {
11566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11567       };
11568     } catch (...) {
11569       {
11570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11571       };
11572     }
11573   }
11574
11575   jresult = result;
11576   return jresult;
11577 }
11578
11579
11580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11581   unsigned int jresult ;
11582   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11583   Dali::Quaternion *arg2 = 0 ;
11584   bool result;
11585
11586   arg1 = (Dali::Quaternion *)jarg1;
11587   arg2 = (Dali::Quaternion *)jarg2;
11588   if (!arg2) {
11589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11590     return 0;
11591   }
11592   {
11593     try {
11594       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11595     } catch (std::out_of_range& e) {
11596       {
11597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11598       };
11599     } catch (std::exception& e) {
11600       {
11601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11602       };
11603     } catch (Dali::DaliException e) {
11604       {
11605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11606       };
11607     } catch (...) {
11608       {
11609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11610       };
11611     }
11612   }
11613
11614   jresult = result;
11615   return jresult;
11616 }
11617
11618
11619 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11620   float jresult ;
11621   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11622   float result;
11623
11624   arg1 = (Dali::Quaternion *)jarg1;
11625   {
11626     try {
11627       result = (float)((Dali::Quaternion const *)arg1)->Length();
11628     } catch (std::out_of_range& e) {
11629       {
11630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11631       };
11632     } catch (std::exception& e) {
11633       {
11634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11635       };
11636     } catch (Dali::DaliException e) {
11637       {
11638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11639       };
11640     } catch (...) {
11641       {
11642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11643       };
11644     }
11645   }
11646
11647   jresult = result;
11648   return jresult;
11649 }
11650
11651
11652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11653   float jresult ;
11654   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11655   float result;
11656
11657   arg1 = (Dali::Quaternion *)jarg1;
11658   {
11659     try {
11660       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11661     } catch (std::out_of_range& e) {
11662       {
11663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11664       };
11665     } catch (std::exception& e) {
11666       {
11667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11668       };
11669     } catch (Dali::DaliException e) {
11670       {
11671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11672       };
11673     } catch (...) {
11674       {
11675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11676       };
11677     }
11678   }
11679
11680   jresult = result;
11681   return jresult;
11682 }
11683
11684
11685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11686   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11687
11688   arg1 = (Dali::Quaternion *)jarg1;
11689   {
11690     try {
11691       (arg1)->Normalize();
11692     } catch (std::out_of_range& e) {
11693       {
11694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11695       };
11696     } catch (std::exception& e) {
11697       {
11698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11699       };
11700     } catch (Dali::DaliException e) {
11701       {
11702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11703       };
11704     } catch (...) {
11705       {
11706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11707       };
11708     }
11709   }
11710
11711 }
11712
11713
11714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11715   void * jresult ;
11716   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11717   Dali::Quaternion result;
11718
11719   arg1 = (Dali::Quaternion *)jarg1;
11720   {
11721     try {
11722       result = ((Dali::Quaternion const *)arg1)->Normalized();
11723     } catch (std::out_of_range& e) {
11724       {
11725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11726       };
11727     } catch (std::exception& e) {
11728       {
11729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11730       };
11731     } catch (Dali::DaliException e) {
11732       {
11733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11734       };
11735     } catch (...) {
11736       {
11737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11738       };
11739     }
11740   }
11741
11742   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11743   return jresult;
11744 }
11745
11746
11747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11748   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11749
11750   arg1 = (Dali::Quaternion *)jarg1;
11751   {
11752     try {
11753       (arg1)->Conjugate();
11754     } catch (std::out_of_range& e) {
11755       {
11756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11757       };
11758     } catch (std::exception& e) {
11759       {
11760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11761       };
11762     } catch (Dali::DaliException e) {
11763       {
11764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11765       };
11766     } catch (...) {
11767       {
11768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11769       };
11770     }
11771   }
11772
11773 }
11774
11775
11776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11777   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11778
11779   arg1 = (Dali::Quaternion *)jarg1;
11780   {
11781     try {
11782       (arg1)->Invert();
11783     } catch (std::out_of_range& e) {
11784       {
11785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11786       };
11787     } catch (std::exception& e) {
11788       {
11789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11790       };
11791     } catch (Dali::DaliException e) {
11792       {
11793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11794       };
11795     } catch (...) {
11796       {
11797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11798       };
11799     }
11800   }
11801
11802 }
11803
11804
11805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11806   void * jresult ;
11807   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11808   Dali::Quaternion result;
11809
11810   arg1 = (Dali::Quaternion *)jarg1;
11811   {
11812     try {
11813       result = ((Dali::Quaternion const *)arg1)->Log();
11814     } catch (std::out_of_range& e) {
11815       {
11816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11817       };
11818     } catch (std::exception& e) {
11819       {
11820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11821       };
11822     } catch (Dali::DaliException e) {
11823       {
11824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11825       };
11826     } catch (...) {
11827       {
11828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11829       };
11830     }
11831   }
11832
11833   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11834   return jresult;
11835 }
11836
11837
11838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11839   void * jresult ;
11840   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11841   Dali::Quaternion result;
11842
11843   arg1 = (Dali::Quaternion *)jarg1;
11844   {
11845     try {
11846       result = ((Dali::Quaternion const *)arg1)->Exp();
11847     } catch (std::out_of_range& e) {
11848       {
11849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11850       };
11851     } catch (std::exception& e) {
11852       {
11853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11854       };
11855     } catch (Dali::DaliException e) {
11856       {
11857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11858       };
11859     } catch (...) {
11860       {
11861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11862       };
11863     }
11864   }
11865
11866   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11867   return jresult;
11868 }
11869
11870
11871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11872   float jresult ;
11873   Dali::Quaternion *arg1 = 0 ;
11874   Dali::Quaternion *arg2 = 0 ;
11875   float result;
11876
11877   arg1 = (Dali::Quaternion *)jarg1;
11878   if (!arg1) {
11879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11880     return 0;
11881   }
11882   arg2 = (Dali::Quaternion *)jarg2;
11883   if (!arg2) {
11884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11885     return 0;
11886   }
11887   {
11888     try {
11889       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11890     } catch (std::out_of_range& e) {
11891       {
11892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11893       };
11894     } catch (std::exception& e) {
11895       {
11896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11897       };
11898     } catch (Dali::DaliException e) {
11899       {
11900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11901       };
11902     } catch (...) {
11903       {
11904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11905       };
11906     }
11907   }
11908
11909   jresult = result;
11910   return jresult;
11911 }
11912
11913
11914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11915   void * jresult ;
11916   Dali::Quaternion *arg1 = 0 ;
11917   Dali::Quaternion *arg2 = 0 ;
11918   float arg3 ;
11919   Dali::Quaternion result;
11920
11921   arg1 = (Dali::Quaternion *)jarg1;
11922   if (!arg1) {
11923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11924     return 0;
11925   }
11926   arg2 = (Dali::Quaternion *)jarg2;
11927   if (!arg2) {
11928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11929     return 0;
11930   }
11931   arg3 = (float)jarg3;
11932   {
11933     try {
11934       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11935     } catch (std::out_of_range& e) {
11936       {
11937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11938       };
11939     } catch (std::exception& e) {
11940       {
11941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11942       };
11943     } catch (Dali::DaliException e) {
11944       {
11945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11946       };
11947     } catch (...) {
11948       {
11949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11950       };
11951     }
11952   }
11953
11954   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11955   return jresult;
11956 }
11957
11958
11959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11960   void * jresult ;
11961   Dali::Quaternion *arg1 = 0 ;
11962   Dali::Quaternion *arg2 = 0 ;
11963   float arg3 ;
11964   Dali::Quaternion result;
11965
11966   arg1 = (Dali::Quaternion *)jarg1;
11967   if (!arg1) {
11968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11969     return 0;
11970   }
11971   arg2 = (Dali::Quaternion *)jarg2;
11972   if (!arg2) {
11973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11974     return 0;
11975   }
11976   arg3 = (float)jarg3;
11977   {
11978     try {
11979       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11980     } catch (std::out_of_range& e) {
11981       {
11982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11983       };
11984     } catch (std::exception& e) {
11985       {
11986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11987       };
11988     } catch (Dali::DaliException e) {
11989       {
11990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11991       };
11992     } catch (...) {
11993       {
11994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11995       };
11996     }
11997   }
11998
11999   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12000   return jresult;
12001 }
12002
12003
12004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12005   void * jresult ;
12006   Dali::Quaternion *arg1 = 0 ;
12007   Dali::Quaternion *arg2 = 0 ;
12008   float arg3 ;
12009   Dali::Quaternion result;
12010
12011   arg1 = (Dali::Quaternion *)jarg1;
12012   if (!arg1) {
12013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12014     return 0;
12015   }
12016   arg2 = (Dali::Quaternion *)jarg2;
12017   if (!arg2) {
12018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12019     return 0;
12020   }
12021   arg3 = (float)jarg3;
12022   {
12023     try {
12024       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12025     } catch (std::out_of_range& e) {
12026       {
12027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12028       };
12029     } catch (std::exception& e) {
12030       {
12031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12032       };
12033     } catch (Dali::DaliException e) {
12034       {
12035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12036       };
12037     } catch (...) {
12038       {
12039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12040       };
12041     }
12042   }
12043
12044   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12045   return jresult;
12046 }
12047
12048
12049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12050   void * jresult ;
12051   Dali::Quaternion *arg1 = 0 ;
12052   Dali::Quaternion *arg2 = 0 ;
12053   Dali::Quaternion *arg3 = 0 ;
12054   Dali::Quaternion *arg4 = 0 ;
12055   float arg5 ;
12056   Dali::Quaternion result;
12057
12058   arg1 = (Dali::Quaternion *)jarg1;
12059   if (!arg1) {
12060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12061     return 0;
12062   }
12063   arg2 = (Dali::Quaternion *)jarg2;
12064   if (!arg2) {
12065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12066     return 0;
12067   }
12068   arg3 = (Dali::Quaternion *)jarg3;
12069   if (!arg3) {
12070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12071     return 0;
12072   }
12073   arg4 = (Dali::Quaternion *)jarg4;
12074   if (!arg4) {
12075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12076     return 0;
12077   }
12078   arg5 = (float)jarg5;
12079   {
12080     try {
12081       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12082     } catch (std::out_of_range& e) {
12083       {
12084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12085       };
12086     } catch (std::exception& e) {
12087       {
12088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12089       };
12090     } catch (Dali::DaliException e) {
12091       {
12092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12093       };
12094     } catch (...) {
12095       {
12096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12097       };
12098     }
12099   }
12100
12101   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12102   return jresult;
12103 }
12104
12105
12106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12107   float jresult ;
12108   Dali::Quaternion *arg1 = 0 ;
12109   Dali::Quaternion *arg2 = 0 ;
12110   float result;
12111
12112   arg1 = (Dali::Quaternion *)jarg1;
12113   if (!arg1) {
12114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12115     return 0;
12116   }
12117   arg2 = (Dali::Quaternion *)jarg2;
12118   if (!arg2) {
12119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12120     return 0;
12121   }
12122   {
12123     try {
12124       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12125     } catch (std::out_of_range& e) {
12126       {
12127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12128       };
12129     } catch (std::exception& e) {
12130       {
12131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12132       };
12133     } catch (Dali::DaliException e) {
12134       {
12135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12136       };
12137     } catch (...) {
12138       {
12139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12140       };
12141     }
12142   }
12143
12144   jresult = result;
12145   return jresult;
12146 }
12147
12148
12149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12150   void * jresult ;
12151   Dali::Matrix *result = 0 ;
12152
12153   {
12154     try {
12155       result = (Dali::Matrix *)new Dali::Matrix();
12156     } catch (std::out_of_range& e) {
12157       {
12158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12159       };
12160     } catch (std::exception& e) {
12161       {
12162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12163       };
12164     } catch (Dali::DaliException e) {
12165       {
12166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12167       };
12168     } catch (...) {
12169       {
12170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12171       };
12172     }
12173   }
12174
12175   jresult = (void *)result;
12176   return jresult;
12177 }
12178
12179
12180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12181   void * jresult ;
12182   bool arg1 ;
12183   Dali::Matrix *result = 0 ;
12184
12185   arg1 = jarg1 ? true : false;
12186   {
12187     try {
12188       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12189     } catch (std::out_of_range& e) {
12190       {
12191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12192       };
12193     } catch (std::exception& e) {
12194       {
12195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12196       };
12197     } catch (Dali::DaliException e) {
12198       {
12199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12200       };
12201     } catch (...) {
12202       {
12203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12204       };
12205     }
12206   }
12207
12208   jresult = (void *)result;
12209   return jresult;
12210 }
12211
12212
12213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12214   void * jresult ;
12215   float *arg1 = (float *) 0 ;
12216   Dali::Matrix *result = 0 ;
12217
12218   arg1 = jarg1;
12219   {
12220     try {
12221       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12222     } catch (std::out_of_range& e) {
12223       {
12224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12225       };
12226     } catch (std::exception& e) {
12227       {
12228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12229       };
12230     } catch (Dali::DaliException e) {
12231       {
12232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12233       };
12234     } catch (...) {
12235       {
12236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12237       };
12238     }
12239   }
12240
12241   jresult = (void *)result;
12242
12243
12244   return jresult;
12245 }
12246
12247
12248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12249   void * jresult ;
12250   Dali::Quaternion *arg1 = 0 ;
12251   Dali::Matrix *result = 0 ;
12252
12253   arg1 = (Dali::Quaternion *)jarg1;
12254   if (!arg1) {
12255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12256     return 0;
12257   }
12258   {
12259     try {
12260       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12261     } catch (std::out_of_range& e) {
12262       {
12263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12264       };
12265     } catch (std::exception& e) {
12266       {
12267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12268       };
12269     } catch (Dali::DaliException e) {
12270       {
12271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12272       };
12273     } catch (...) {
12274       {
12275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12276       };
12277     }
12278   }
12279
12280   jresult = (void *)result;
12281   return jresult;
12282 }
12283
12284
12285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12286   void * jresult ;
12287   Dali::Matrix *arg1 = 0 ;
12288   Dali::Matrix *result = 0 ;
12289
12290   arg1 = (Dali::Matrix *)jarg1;
12291   if (!arg1) {
12292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12293     return 0;
12294   }
12295   {
12296     try {
12297       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12298     } catch (std::out_of_range& e) {
12299       {
12300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12301       };
12302     } catch (std::exception& e) {
12303       {
12304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12305       };
12306     } catch (Dali::DaliException e) {
12307       {
12308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12309       };
12310     } catch (...) {
12311       {
12312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12313       };
12314     }
12315   }
12316
12317   jresult = (void *)result;
12318   return jresult;
12319 }
12320
12321
12322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12323   void * jresult ;
12324   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12325   Dali::Matrix *arg2 = 0 ;
12326   Dali::Matrix *result = 0 ;
12327
12328   arg1 = (Dali::Matrix *)jarg1;
12329   arg2 = (Dali::Matrix *)jarg2;
12330   if (!arg2) {
12331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12332     return 0;
12333   }
12334   {
12335     try {
12336       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12337     } catch (std::out_of_range& e) {
12338       {
12339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12340       };
12341     } catch (std::exception& e) {
12342       {
12343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12344       };
12345     } catch (Dali::DaliException e) {
12346       {
12347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12348       };
12349     } catch (...) {
12350       {
12351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12352       };
12353     }
12354   }
12355
12356   jresult = (void *)result;
12357   return jresult;
12358 }
12359
12360
12361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12362   void * jresult ;
12363   Dali::Matrix *result = 0 ;
12364
12365   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12366   jresult = (void *)result;
12367   return jresult;
12368 }
12369
12370
12371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12372   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12373
12374   arg1 = (Dali::Matrix *)jarg1;
12375   {
12376     try {
12377       (arg1)->SetIdentity();
12378     } catch (std::out_of_range& e) {
12379       {
12380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12381       };
12382     } catch (std::exception& e) {
12383       {
12384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12385       };
12386     } catch (Dali::DaliException e) {
12387       {
12388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12389       };
12390     } catch (...) {
12391       {
12392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12393       };
12394     }
12395   }
12396
12397 }
12398
12399
12400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12401   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12402   Dali::Vector3 *arg2 = 0 ;
12403
12404   arg1 = (Dali::Matrix *)jarg1;
12405   arg2 = (Dali::Vector3 *)jarg2;
12406   if (!arg2) {
12407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12408     return ;
12409   }
12410   {
12411     try {
12412       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12413     } catch (std::out_of_range& e) {
12414       {
12415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12416       };
12417     } catch (std::exception& e) {
12418       {
12419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12420       };
12421     } catch (Dali::DaliException e) {
12422       {
12423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12424       };
12425     } catch (...) {
12426       {
12427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12428       };
12429     }
12430   }
12431
12432 }
12433
12434
12435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12436   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12437   Dali::Matrix *arg2 = 0 ;
12438
12439   arg1 = (Dali::Matrix *)jarg1;
12440   arg2 = (Dali::Matrix *)jarg2;
12441   if (!arg2) {
12442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12443     return ;
12444   }
12445   {
12446     try {
12447       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12448     } catch (std::out_of_range& e) {
12449       {
12450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12451       };
12452     } catch (std::exception& e) {
12453       {
12454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12455       };
12456     } catch (Dali::DaliException e) {
12457       {
12458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12459       };
12460     } catch (...) {
12461       {
12462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12463       };
12464     }
12465   }
12466
12467 }
12468
12469
12470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12471   unsigned int jresult ;
12472   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12473   bool result;
12474
12475   arg1 = (Dali::Matrix *)jarg1;
12476   {
12477     try {
12478       result = (bool)(arg1)->Invert();
12479     } catch (std::out_of_range& e) {
12480       {
12481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12482       };
12483     } catch (std::exception& e) {
12484       {
12485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12486       };
12487     } catch (Dali::DaliException e) {
12488       {
12489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12490       };
12491     } catch (...) {
12492       {
12493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12494       };
12495     }
12496   }
12497
12498   jresult = result;
12499   return jresult;
12500 }
12501
12502
12503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12504   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12505
12506   arg1 = (Dali::Matrix *)jarg1;
12507   {
12508     try {
12509       (arg1)->Transpose();
12510     } catch (std::out_of_range& e) {
12511       {
12512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12513       };
12514     } catch (std::exception& e) {
12515       {
12516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12517       };
12518     } catch (Dali::DaliException e) {
12519       {
12520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12521       };
12522     } catch (...) {
12523       {
12524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12525       };
12526     }
12527   }
12528
12529 }
12530
12531
12532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12533   void * jresult ;
12534   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12535   Dali::Vector3 result;
12536
12537   arg1 = (Dali::Matrix *)jarg1;
12538   {
12539     try {
12540       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12541     } catch (std::out_of_range& e) {
12542       {
12543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12544       };
12545     } catch (std::exception& e) {
12546       {
12547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12548       };
12549     } catch (Dali::DaliException e) {
12550       {
12551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12552       };
12553     } catch (...) {
12554       {
12555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12556       };
12557     }
12558   }
12559
12560   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12561   return jresult;
12562 }
12563
12564
12565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12566   void * jresult ;
12567   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12568   Dali::Vector3 result;
12569
12570   arg1 = (Dali::Matrix *)jarg1;
12571   {
12572     try {
12573       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12574     } catch (std::out_of_range& e) {
12575       {
12576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12577       };
12578     } catch (std::exception& e) {
12579       {
12580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12581       };
12582     } catch (Dali::DaliException e) {
12583       {
12584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12585       };
12586     } catch (...) {
12587       {
12588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12589       };
12590     }
12591   }
12592
12593   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12594   return jresult;
12595 }
12596
12597
12598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12599   void * jresult ;
12600   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12601   Dali::Vector3 result;
12602
12603   arg1 = (Dali::Matrix *)jarg1;
12604   {
12605     try {
12606       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12607     } catch (std::out_of_range& e) {
12608       {
12609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12610       };
12611     } catch (std::exception& e) {
12612       {
12613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12614       };
12615     } catch (Dali::DaliException e) {
12616       {
12617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12618       };
12619     } catch (...) {
12620       {
12621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12622       };
12623     }
12624   }
12625
12626   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12627   return jresult;
12628 }
12629
12630
12631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12632   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12633   Dali::Vector3 *arg2 = 0 ;
12634
12635   arg1 = (Dali::Matrix *)jarg1;
12636   arg2 = (Dali::Vector3 *)jarg2;
12637   if (!arg2) {
12638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12639     return ;
12640   }
12641   {
12642     try {
12643       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12644     } catch (std::out_of_range& e) {
12645       {
12646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12647       };
12648     } catch (std::exception& e) {
12649       {
12650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12651       };
12652     } catch (Dali::DaliException e) {
12653       {
12654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12655       };
12656     } catch (...) {
12657       {
12658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12659       };
12660     }
12661   }
12662
12663 }
12664
12665
12666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12667   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12668   Dali::Vector3 *arg2 = 0 ;
12669
12670   arg1 = (Dali::Matrix *)jarg1;
12671   arg2 = (Dali::Vector3 *)jarg2;
12672   if (!arg2) {
12673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12674     return ;
12675   }
12676   {
12677     try {
12678       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12679     } catch (std::out_of_range& e) {
12680       {
12681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12682       };
12683     } catch (std::exception& e) {
12684       {
12685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12686       };
12687     } catch (Dali::DaliException e) {
12688       {
12689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12690       };
12691     } catch (...) {
12692       {
12693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12694       };
12695     }
12696   }
12697
12698 }
12699
12700
12701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12702   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12703   Dali::Vector3 *arg2 = 0 ;
12704
12705   arg1 = (Dali::Matrix *)jarg1;
12706   arg2 = (Dali::Vector3 *)jarg2;
12707   if (!arg2) {
12708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12709     return ;
12710   }
12711   {
12712     try {
12713       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12714     } catch (std::out_of_range& e) {
12715       {
12716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12717       };
12718     } catch (std::exception& e) {
12719       {
12720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12721       };
12722     } catch (Dali::DaliException e) {
12723       {
12724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12725       };
12726     } catch (...) {
12727       {
12728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12729       };
12730     }
12731   }
12732
12733 }
12734
12735
12736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12737   void * jresult ;
12738   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12739   Dali::Vector4 *result = 0 ;
12740
12741   arg1 = (Dali::Matrix *)jarg1;
12742   {
12743     try {
12744       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12745     } catch (std::out_of_range& e) {
12746       {
12747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12748       };
12749     } catch (std::exception& e) {
12750       {
12751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12752       };
12753     } catch (Dali::DaliException e) {
12754       {
12755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12756       };
12757     } catch (...) {
12758       {
12759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12760       };
12761     }
12762   }
12763
12764   jresult = (void *)result;
12765   return jresult;
12766 }
12767
12768
12769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12770   void * jresult ;
12771   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12772   Dali::Vector3 *result = 0 ;
12773
12774   arg1 = (Dali::Matrix *)jarg1;
12775   {
12776     try {
12777       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12778     } catch (std::out_of_range& e) {
12779       {
12780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12781       };
12782     } catch (std::exception& e) {
12783       {
12784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12785       };
12786     } catch (Dali::DaliException e) {
12787       {
12788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12789       };
12790     } catch (...) {
12791       {
12792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12793       };
12794     }
12795   }
12796
12797   jresult = (void *)result;
12798   return jresult;
12799 }
12800
12801
12802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12803   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12804   Dali::Vector4 *arg2 = 0 ;
12805
12806   arg1 = (Dali::Matrix *)jarg1;
12807   arg2 = (Dali::Vector4 *)jarg2;
12808   if (!arg2) {
12809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12810     return ;
12811   }
12812   {
12813     try {
12814       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12815     } catch (std::out_of_range& e) {
12816       {
12817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12818       };
12819     } catch (std::exception& e) {
12820       {
12821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12822       };
12823     } catch (Dali::DaliException e) {
12824       {
12825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12826       };
12827     } catch (...) {
12828       {
12829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12830       };
12831     }
12832   }
12833
12834 }
12835
12836
12837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12838   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12839   Dali::Vector3 *arg2 = 0 ;
12840
12841   arg1 = (Dali::Matrix *)jarg1;
12842   arg2 = (Dali::Vector3 *)jarg2;
12843   if (!arg2) {
12844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12845     return ;
12846   }
12847   {
12848     try {
12849       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12850     } catch (std::out_of_range& e) {
12851       {
12852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12853       };
12854     } catch (std::exception& e) {
12855       {
12856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12857       };
12858     } catch (Dali::DaliException e) {
12859       {
12860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12861       };
12862     } catch (...) {
12863       {
12864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12865       };
12866     }
12867   }
12868
12869 }
12870
12871
12872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12873   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12874
12875   arg1 = (Dali::Matrix *)jarg1;
12876   {
12877     try {
12878       (arg1)->OrthoNormalize();
12879     } catch (std::out_of_range& e) {
12880       {
12881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12882       };
12883     } catch (std::exception& e) {
12884       {
12885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12886       };
12887     } catch (Dali::DaliException e) {
12888       {
12889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12890       };
12891     } catch (...) {
12892       {
12893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12894       };
12895     }
12896   }
12897
12898 }
12899
12900
12901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12902   void * jresult ;
12903   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12904   float *result = 0 ;
12905
12906   arg1 = (Dali::Matrix *)jarg1;
12907   {
12908     try {
12909       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12910     } catch (std::out_of_range& e) {
12911       {
12912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12913       };
12914     } catch (std::exception& e) {
12915       {
12916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12917       };
12918     } catch (Dali::DaliException e) {
12919       {
12920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12921       };
12922     } catch (...) {
12923       {
12924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12925       };
12926     }
12927   }
12928
12929   jresult = (void *)result;
12930   return jresult;
12931 }
12932
12933
12934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12935   Dali::Matrix *arg1 = 0 ;
12936   Dali::Matrix *arg2 = 0 ;
12937   Dali::Matrix *arg3 = 0 ;
12938
12939   arg1 = (Dali::Matrix *)jarg1;
12940   if (!arg1) {
12941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12942     return ;
12943   }
12944   arg2 = (Dali::Matrix *)jarg2;
12945   if (!arg2) {
12946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12947     return ;
12948   }
12949   arg3 = (Dali::Matrix *)jarg3;
12950   if (!arg3) {
12951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12952     return ;
12953   }
12954   {
12955     try {
12956       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12957     } catch (std::out_of_range& e) {
12958       {
12959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12960       };
12961     } catch (std::exception& e) {
12962       {
12963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12964       };
12965     } catch (Dali::DaliException e) {
12966       {
12967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12968       };
12969     } catch (...) {
12970       {
12971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12972       };
12973     }
12974   }
12975
12976 }
12977
12978
12979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
12980   Dali::Matrix *arg1 = 0 ;
12981   Dali::Matrix *arg2 = 0 ;
12982   Dali::Quaternion *arg3 = 0 ;
12983
12984   arg1 = (Dali::Matrix *)jarg1;
12985   if (!arg1) {
12986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12987     return ;
12988   }
12989   arg2 = (Dali::Matrix *)jarg2;
12990   if (!arg2) {
12991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12992     return ;
12993   }
12994   arg3 = (Dali::Quaternion *)jarg3;
12995   if (!arg3) {
12996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12997     return ;
12998   }
12999   {
13000     try {
13001       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13002     } catch (std::out_of_range& e) {
13003       {
13004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13005       };
13006     } catch (std::exception& e) {
13007       {
13008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13009       };
13010     } catch (Dali::DaliException e) {
13011       {
13012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13013       };
13014     } catch (...) {
13015       {
13016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13017       };
13018     }
13019   }
13020
13021 }
13022
13023
13024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13025   void * jresult ;
13026   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13027   Dali::Vector4 *arg2 = 0 ;
13028   Dali::Vector4 result;
13029
13030   arg1 = (Dali::Matrix *)jarg1;
13031   arg2 = (Dali::Vector4 *)jarg2;
13032   if (!arg2) {
13033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13034     return 0;
13035   }
13036   {
13037     try {
13038       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13039     } catch (std::out_of_range& e) {
13040       {
13041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13042       };
13043     } catch (std::exception& e) {
13044       {
13045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13046       };
13047     } catch (Dali::DaliException e) {
13048       {
13049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13050       };
13051     } catch (...) {
13052       {
13053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13054       };
13055     }
13056   }
13057
13058   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13059   return jresult;
13060 }
13061
13062
13063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13064   unsigned int jresult ;
13065   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13066   Dali::Matrix *arg2 = 0 ;
13067   bool result;
13068
13069   arg1 = (Dali::Matrix *)jarg1;
13070   arg2 = (Dali::Matrix *)jarg2;
13071   if (!arg2) {
13072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13073     return 0;
13074   }
13075   {
13076     try {
13077       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13078     } catch (std::out_of_range& e) {
13079       {
13080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13081       };
13082     } catch (std::exception& e) {
13083       {
13084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13085       };
13086     } catch (Dali::DaliException e) {
13087       {
13088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13089       };
13090     } catch (...) {
13091       {
13092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13093       };
13094     }
13095   }
13096
13097   jresult = result;
13098   return jresult;
13099 }
13100
13101
13102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13103   unsigned int jresult ;
13104   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13105   Dali::Matrix *arg2 = 0 ;
13106   bool result;
13107
13108   arg1 = (Dali::Matrix *)jarg1;
13109   arg2 = (Dali::Matrix *)jarg2;
13110   if (!arg2) {
13111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13112     return 0;
13113   }
13114   {
13115     try {
13116       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13117     } catch (std::out_of_range& e) {
13118       {
13119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13120       };
13121     } catch (std::exception& e) {
13122       {
13123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13124       };
13125     } catch (Dali::DaliException e) {
13126       {
13127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13128       };
13129     } catch (...) {
13130       {
13131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13132       };
13133     }
13134   }
13135
13136   jresult = result;
13137   return jresult;
13138 }
13139
13140
13141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13142   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13143   Dali::Vector3 *arg2 = 0 ;
13144   Dali::Quaternion *arg3 = 0 ;
13145   Dali::Vector3 *arg4 = 0 ;
13146
13147   arg1 = (Dali::Matrix *)jarg1;
13148   arg2 = (Dali::Vector3 *)jarg2;
13149   if (!arg2) {
13150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13151     return ;
13152   }
13153   arg3 = (Dali::Quaternion *)jarg3;
13154   if (!arg3) {
13155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13156     return ;
13157   }
13158   arg4 = (Dali::Vector3 *)jarg4;
13159   if (!arg4) {
13160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13161     return ;
13162   }
13163   {
13164     try {
13165       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13166     } catch (std::out_of_range& e) {
13167       {
13168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13169       };
13170     } catch (std::exception& e) {
13171       {
13172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13173       };
13174     } catch (Dali::DaliException e) {
13175       {
13176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13177       };
13178     } catch (...) {
13179       {
13180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13181       };
13182     }
13183   }
13184
13185 }
13186
13187
13188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13189   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13190   Dali::Vector3 *arg2 = 0 ;
13191   Dali::Quaternion *arg3 = 0 ;
13192   Dali::Vector3 *arg4 = 0 ;
13193
13194   arg1 = (Dali::Matrix *)jarg1;
13195   arg2 = (Dali::Vector3 *)jarg2;
13196   if (!arg2) {
13197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13198     return ;
13199   }
13200   arg3 = (Dali::Quaternion *)jarg3;
13201   if (!arg3) {
13202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13203     return ;
13204   }
13205   arg4 = (Dali::Vector3 *)jarg4;
13206   if (!arg4) {
13207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13208     return ;
13209   }
13210   {
13211     try {
13212       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13213     } catch (std::out_of_range& e) {
13214       {
13215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13216       };
13217     } catch (std::exception& e) {
13218       {
13219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13220       };
13221     } catch (Dali::DaliException e) {
13222       {
13223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13224       };
13225     } catch (...) {
13226       {
13227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13228       };
13229     }
13230   }
13231
13232 }
13233
13234
13235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13236   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13237   Dali::Vector3 *arg2 = 0 ;
13238   Dali::Vector3 *arg3 = 0 ;
13239   Dali::Vector3 *arg4 = 0 ;
13240   Dali::Vector3 *arg5 = 0 ;
13241
13242   arg1 = (Dali::Matrix *)jarg1;
13243   arg2 = (Dali::Vector3 *)jarg2;
13244   if (!arg2) {
13245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13246     return ;
13247   }
13248   arg3 = (Dali::Vector3 *)jarg3;
13249   if (!arg3) {
13250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13251     return ;
13252   }
13253   arg4 = (Dali::Vector3 *)jarg4;
13254   if (!arg4) {
13255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13256     return ;
13257   }
13258   arg5 = (Dali::Vector3 *)jarg5;
13259   if (!arg5) {
13260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13261     return ;
13262   }
13263   {
13264     try {
13265       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13266     } catch (std::out_of_range& e) {
13267       {
13268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13269       };
13270     } catch (std::exception& e) {
13271       {
13272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13273       };
13274     } catch (Dali::DaliException e) {
13275       {
13276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13277       };
13278     } catch (...) {
13279       {
13280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13281       };
13282     }
13283   }
13284
13285 }
13286
13287
13288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13289   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13290   Dali::Vector3 *arg2 = 0 ;
13291   Dali::Quaternion *arg3 = 0 ;
13292   Dali::Vector3 *arg4 = 0 ;
13293
13294   arg1 = (Dali::Matrix *)jarg1;
13295   arg2 = (Dali::Vector3 *)jarg2;
13296   if (!arg2) {
13297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13298     return ;
13299   }
13300   arg3 = (Dali::Quaternion *)jarg3;
13301   if (!arg3) {
13302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13303     return ;
13304   }
13305   arg4 = (Dali::Vector3 *)jarg4;
13306   if (!arg4) {
13307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13308     return ;
13309   }
13310   {
13311     try {
13312       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13313     } catch (std::out_of_range& e) {
13314       {
13315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13316       };
13317     } catch (std::exception& e) {
13318       {
13319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13320       };
13321     } catch (Dali::DaliException e) {
13322       {
13323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13324       };
13325     } catch (...) {
13326       {
13327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13328       };
13329     }
13330   }
13331
13332 }
13333
13334
13335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13336   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13337
13338   arg1 = (Dali::Matrix *)jarg1;
13339   {
13340     try {
13341       delete arg1;
13342     } catch (std::out_of_range& e) {
13343       {
13344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13345       };
13346     } catch (std::exception& e) {
13347       {
13348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13349       };
13350     } catch (Dali::DaliException e) {
13351       {
13352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13353       };
13354     } catch (...) {
13355       {
13356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13357       };
13358     }
13359   }
13360
13361 }
13362
13363
13364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13365   void * jresult ;
13366   Dali::Matrix3 *result = 0 ;
13367
13368   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13369   jresult = (void *)result;
13370   return jresult;
13371 }
13372
13373
13374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13375   void * jresult ;
13376   Dali::Matrix3 *result = 0 ;
13377
13378   {
13379     try {
13380       result = (Dali::Matrix3 *)new Dali::Matrix3();
13381     } catch (std::out_of_range& e) {
13382       {
13383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13384       };
13385     } catch (std::exception& e) {
13386       {
13387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13388       };
13389     } catch (Dali::DaliException e) {
13390       {
13391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13392       };
13393     } catch (...) {
13394       {
13395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13396       };
13397     }
13398   }
13399
13400   jresult = (void *)result;
13401   return jresult;
13402 }
13403
13404
13405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13406   void * jresult ;
13407   Dali::Matrix3 *arg1 = 0 ;
13408   Dali::Matrix3 *result = 0 ;
13409
13410   arg1 = (Dali::Matrix3 *)jarg1;
13411   if (!arg1) {
13412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13413     return 0;
13414   }
13415   {
13416     try {
13417       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13418     } catch (std::out_of_range& e) {
13419       {
13420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13421       };
13422     } catch (std::exception& e) {
13423       {
13424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13425       };
13426     } catch (Dali::DaliException e) {
13427       {
13428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13429       };
13430     } catch (...) {
13431       {
13432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13433       };
13434     }
13435   }
13436
13437   jresult = (void *)result;
13438   return jresult;
13439 }
13440
13441
13442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13443   void * jresult ;
13444   Dali::Matrix *arg1 = 0 ;
13445   Dali::Matrix3 *result = 0 ;
13446
13447   arg1 = (Dali::Matrix *)jarg1;
13448   if (!arg1) {
13449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13450     return 0;
13451   }
13452   {
13453     try {
13454       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13455     } catch (std::out_of_range& e) {
13456       {
13457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13458       };
13459     } catch (std::exception& e) {
13460       {
13461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13462       };
13463     } catch (Dali::DaliException e) {
13464       {
13465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13466       };
13467     } catch (...) {
13468       {
13469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13470       };
13471     }
13472   }
13473
13474   jresult = (void *)result;
13475   return jresult;
13476 }
13477
13478
13479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
13480   void * jresult ;
13481   float arg1 ;
13482   float arg2 ;
13483   float arg3 ;
13484   float arg4 ;
13485   float arg5 ;
13486   float arg6 ;
13487   float arg7 ;
13488   float arg8 ;
13489   float arg9 ;
13490   Dali::Matrix3 *result = 0 ;
13491
13492   arg1 = (float)jarg1;
13493   arg2 = (float)jarg2;
13494   arg3 = (float)jarg3;
13495   arg4 = (float)jarg4;
13496   arg5 = (float)jarg5;
13497   arg6 = (float)jarg6;
13498   arg7 = (float)jarg7;
13499   arg8 = (float)jarg8;
13500   arg9 = (float)jarg9;
13501   {
13502     try {
13503       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13504     } catch (std::out_of_range& e) {
13505       {
13506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13507       };
13508     } catch (std::exception& e) {
13509       {
13510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13511       };
13512     } catch (Dali::DaliException e) {
13513       {
13514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13515       };
13516     } catch (...) {
13517       {
13518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13519       };
13520     }
13521   }
13522
13523   jresult = (void *)result;
13524   return jresult;
13525 }
13526
13527
13528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13529   void * jresult ;
13530   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13531   Dali::Matrix3 *arg2 = 0 ;
13532   Dali::Matrix3 *result = 0 ;
13533
13534   arg1 = (Dali::Matrix3 *)jarg1;
13535   arg2 = (Dali::Matrix3 *)jarg2;
13536   if (!arg2) {
13537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13538     return 0;
13539   }
13540   {
13541     try {
13542       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13543     } catch (std::out_of_range& e) {
13544       {
13545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13546       };
13547     } catch (std::exception& e) {
13548       {
13549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13550       };
13551     } catch (Dali::DaliException e) {
13552       {
13553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13554       };
13555     } catch (...) {
13556       {
13557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13558       };
13559     }
13560   }
13561
13562   jresult = (void *)result;
13563   return jresult;
13564 }
13565
13566
13567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13568   void * jresult ;
13569   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13570   Dali::Matrix *arg2 = 0 ;
13571   Dali::Matrix3 *result = 0 ;
13572
13573   arg1 = (Dali::Matrix3 *)jarg1;
13574   arg2 = (Dali::Matrix *)jarg2;
13575   if (!arg2) {
13576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13577     return 0;
13578   }
13579   {
13580     try {
13581       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13582     } catch (std::out_of_range& e) {
13583       {
13584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13585       };
13586     } catch (std::exception& e) {
13587       {
13588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13589       };
13590     } catch (Dali::DaliException e) {
13591       {
13592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13593       };
13594     } catch (...) {
13595       {
13596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13597       };
13598     }
13599   }
13600
13601   jresult = (void *)result;
13602   return jresult;
13603 }
13604
13605
13606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13607   unsigned int jresult ;
13608   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13609   Dali::Matrix3 *arg2 = 0 ;
13610   bool result;
13611
13612   arg1 = (Dali::Matrix3 *)jarg1;
13613   arg2 = (Dali::Matrix3 *)jarg2;
13614   if (!arg2) {
13615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13616     return 0;
13617   }
13618   {
13619     try {
13620       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13621     } catch (std::out_of_range& e) {
13622       {
13623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13624       };
13625     } catch (std::exception& e) {
13626       {
13627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13628       };
13629     } catch (Dali::DaliException e) {
13630       {
13631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13632       };
13633     } catch (...) {
13634       {
13635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13636       };
13637     }
13638   }
13639
13640   jresult = result;
13641   return jresult;
13642 }
13643
13644
13645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13646   unsigned int jresult ;
13647   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13648   Dali::Matrix3 *arg2 = 0 ;
13649   bool result;
13650
13651   arg1 = (Dali::Matrix3 *)jarg1;
13652   arg2 = (Dali::Matrix3 *)jarg2;
13653   if (!arg2) {
13654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13655     return 0;
13656   }
13657   {
13658     try {
13659       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13660     } catch (std::out_of_range& e) {
13661       {
13662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13663       };
13664     } catch (std::exception& e) {
13665       {
13666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13667       };
13668     } catch (Dali::DaliException e) {
13669       {
13670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13671       };
13672     } catch (...) {
13673       {
13674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13675       };
13676     }
13677   }
13678
13679   jresult = result;
13680   return jresult;
13681 }
13682
13683
13684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13685   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13686
13687   arg1 = (Dali::Matrix3 *)jarg1;
13688   {
13689     try {
13690       delete arg1;
13691     } catch (std::out_of_range& e) {
13692       {
13693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13694       };
13695     } catch (std::exception& e) {
13696       {
13697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13698       };
13699     } catch (Dali::DaliException e) {
13700       {
13701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13702       };
13703     } catch (...) {
13704       {
13705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13706       };
13707     }
13708   }
13709
13710 }
13711
13712
13713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13714   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13715
13716   arg1 = (Dali::Matrix3 *)jarg1;
13717   {
13718     try {
13719       (arg1)->SetIdentity();
13720     } catch (std::out_of_range& e) {
13721       {
13722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13723       };
13724     } catch (std::exception& e) {
13725       {
13726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13727       };
13728     } catch (Dali::DaliException e) {
13729       {
13730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13731       };
13732     } catch (...) {
13733       {
13734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13735       };
13736     }
13737   }
13738
13739 }
13740
13741
13742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13743   void * jresult ;
13744   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13745   float *result = 0 ;
13746
13747   arg1 = (Dali::Matrix3 *)jarg1;
13748   {
13749     try {
13750       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13751     } catch (std::out_of_range& e) {
13752       {
13753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13754       };
13755     } catch (std::exception& e) {
13756       {
13757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13758       };
13759     } catch (Dali::DaliException e) {
13760       {
13761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13762       };
13763     } catch (...) {
13764       {
13765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13766       };
13767     }
13768   }
13769
13770   jresult = (void *)result;
13771   return jresult;
13772 }
13773
13774
13775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13776   unsigned int jresult ;
13777   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13778   bool result;
13779
13780   arg1 = (Dali::Matrix3 *)jarg1;
13781   {
13782     try {
13783       result = (bool)(arg1)->Invert();
13784     } catch (std::out_of_range& e) {
13785       {
13786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13787       };
13788     } catch (std::exception& e) {
13789       {
13790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13791       };
13792     } catch (Dali::DaliException e) {
13793       {
13794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13795       };
13796     } catch (...) {
13797       {
13798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13799       };
13800     }
13801   }
13802
13803   jresult = result;
13804   return jresult;
13805 }
13806
13807
13808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13809   unsigned int jresult ;
13810   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13811   bool result;
13812
13813   arg1 = (Dali::Matrix3 *)jarg1;
13814   {
13815     try {
13816       result = (bool)(arg1)->Transpose();
13817     } catch (std::out_of_range& e) {
13818       {
13819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13820       };
13821     } catch (std::exception& e) {
13822       {
13823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13824       };
13825     } catch (Dali::DaliException e) {
13826       {
13827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13828       };
13829     } catch (...) {
13830       {
13831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13832       };
13833     }
13834   }
13835
13836   jresult = result;
13837   return jresult;
13838 }
13839
13840
13841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13842   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13843   float arg2 ;
13844
13845   arg1 = (Dali::Matrix3 *)jarg1;
13846   arg2 = (float)jarg2;
13847   {
13848     try {
13849       (arg1)->Scale(arg2);
13850     } catch (std::out_of_range& e) {
13851       {
13852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13853       };
13854     } catch (std::exception& e) {
13855       {
13856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13857       };
13858     } catch (Dali::DaliException e) {
13859       {
13860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13861       };
13862     } catch (...) {
13863       {
13864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13865       };
13866     }
13867   }
13868
13869 }
13870
13871
13872 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13873   float jresult ;
13874   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13875   float result;
13876
13877   arg1 = (Dali::Matrix3 *)jarg1;
13878   {
13879     try {
13880       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13881     } catch (std::out_of_range& e) {
13882       {
13883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13884       };
13885     } catch (std::exception& e) {
13886       {
13887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13888       };
13889     } catch (Dali::DaliException e) {
13890       {
13891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13892       };
13893     } catch (...) {
13894       {
13895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13896       };
13897     }
13898   }
13899
13900   jresult = result;
13901   return jresult;
13902 }
13903
13904
13905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13906   unsigned int jresult ;
13907   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13908   bool result;
13909
13910   arg1 = (Dali::Matrix3 *)jarg1;
13911   {
13912     try {
13913       result = (bool)(arg1)->ScaledInverseTranspose();
13914     } catch (std::out_of_range& e) {
13915       {
13916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13917       };
13918     } catch (std::exception& e) {
13919       {
13920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13921       };
13922     } catch (Dali::DaliException e) {
13923       {
13924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13925       };
13926     } catch (...) {
13927       {
13928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13929       };
13930     }
13931   }
13932
13933   jresult = result;
13934   return jresult;
13935 }
13936
13937
13938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13939   Dali::Matrix3 *arg1 = 0 ;
13940   Dali::Matrix3 *arg2 = 0 ;
13941   Dali::Matrix3 *arg3 = 0 ;
13942
13943   arg1 = (Dali::Matrix3 *)jarg1;
13944   if (!arg1) {
13945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13946     return ;
13947   }
13948   arg2 = (Dali::Matrix3 *)jarg2;
13949   if (!arg2) {
13950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13951     return ;
13952   }
13953   arg3 = (Dali::Matrix3 *)jarg3;
13954   if (!arg3) {
13955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13956     return ;
13957   }
13958   {
13959     try {
13960       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13961     } catch (std::out_of_range& e) {
13962       {
13963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13964       };
13965     } catch (std::exception& e) {
13966       {
13967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13968       };
13969     } catch (Dali::DaliException e) {
13970       {
13971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13972       };
13973     } catch (...) {
13974       {
13975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13976       };
13977     }
13978   }
13979
13980 }
13981
13982
13983 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
13984   float jresult ;
13985   float arg1 ;
13986   float arg2 ;
13987   float result;
13988
13989   arg1 = (float)jarg1;
13990   arg2 = (float)jarg2;
13991   {
13992     try {
13993       result = (float)Dali::Random::Range(arg1,arg2);
13994     } catch (std::out_of_range& e) {
13995       {
13996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13997       };
13998     } catch (std::exception& e) {
13999       {
14000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14001       };
14002     } catch (Dali::DaliException e) {
14003       {
14004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14005       };
14006     } catch (...) {
14007       {
14008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14009       };
14010     }
14011   }
14012
14013   jresult = result;
14014   return jresult;
14015 }
14016
14017
14018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14019   void * jresult ;
14020   Dali::Vector4 result;
14021
14022   {
14023     try {
14024       result = Dali::Random::Axis();
14025     } catch (std::out_of_range& e) {
14026       {
14027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14028       };
14029     } catch (std::exception& e) {
14030       {
14031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14032       };
14033     } catch (Dali::DaliException e) {
14034       {
14035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14036       };
14037     } catch (...) {
14038       {
14039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14040       };
14041     }
14042   }
14043
14044   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14045   return jresult;
14046 }
14047
14048
14049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14050   void * jresult ;
14051   Dali::AngleAxis *result = 0 ;
14052
14053   {
14054     try {
14055       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14056     } catch (std::out_of_range& e) {
14057       {
14058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14059       };
14060     } catch (std::exception& e) {
14061       {
14062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14063       };
14064     } catch (Dali::DaliException e) {
14065       {
14066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14067       };
14068     } catch (...) {
14069       {
14070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14071       };
14072     }
14073   }
14074
14075   jresult = (void *)result;
14076   return jresult;
14077 }
14078
14079
14080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14081   void * jresult ;
14082   Dali::Radian arg1 ;
14083   Dali::Vector3 *arg2 = 0 ;
14084   Dali::Radian *argp1 ;
14085   Dali::AngleAxis *result = 0 ;
14086
14087   argp1 = (Dali::Radian *)jarg1;
14088   if (!argp1) {
14089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14090     return 0;
14091   }
14092   arg1 = *argp1;
14093   arg2 = (Dali::Vector3 *)jarg2;
14094   if (!arg2) {
14095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14096     return 0;
14097   }
14098   {
14099     try {
14100       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14101     } catch (std::out_of_range& e) {
14102       {
14103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14104       };
14105     } catch (std::exception& e) {
14106       {
14107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14108       };
14109     } catch (Dali::DaliException e) {
14110       {
14111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14112       };
14113     } catch (...) {
14114       {
14115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14116       };
14117     }
14118   }
14119
14120   jresult = (void *)result;
14121   return jresult;
14122 }
14123
14124
14125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14126   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14127   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14128
14129   arg1 = (Dali::AngleAxis *)jarg1;
14130   arg2 = (Dali::Radian *)jarg2;
14131   if (arg1) (arg1)->angle = *arg2;
14132 }
14133
14134
14135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14136   void * jresult ;
14137   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14138   Dali::Radian *result = 0 ;
14139
14140   arg1 = (Dali::AngleAxis *)jarg1;
14141   result = (Dali::Radian *)& ((arg1)->angle);
14142   jresult = (void *)result;
14143   return jresult;
14144 }
14145
14146
14147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14148   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14149   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14150
14151   arg1 = (Dali::AngleAxis *)jarg1;
14152   arg2 = (Dali::Vector3 *)jarg2;
14153   if (arg1) (arg1)->axis = *arg2;
14154 }
14155
14156
14157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14158   void * jresult ;
14159   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14160   Dali::Vector3 *result = 0 ;
14161
14162   arg1 = (Dali::AngleAxis *)jarg1;
14163   result = (Dali::Vector3 *)& ((arg1)->axis);
14164   jresult = (void *)result;
14165   return jresult;
14166 }
14167
14168
14169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14170   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14171
14172   arg1 = (Dali::AngleAxis *)jarg1;
14173   {
14174     try {
14175       delete arg1;
14176     } catch (std::out_of_range& e) {
14177       {
14178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14179       };
14180     } catch (std::exception& e) {
14181       {
14182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14183       };
14184     } catch (Dali::DaliException e) {
14185       {
14186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14187       };
14188     } catch (...) {
14189       {
14190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14191       };
14192     }
14193   }
14194
14195 }
14196
14197
14198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14199   unsigned int jresult ;
14200   Dali::AngleAxis *arg1 = 0 ;
14201   Dali::AngleAxis *arg2 = 0 ;
14202   bool result;
14203
14204   arg1 = (Dali::AngleAxis *)jarg1;
14205   if (!arg1) {
14206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14207     return 0;
14208   }
14209   arg2 = (Dali::AngleAxis *)jarg2;
14210   if (!arg2) {
14211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14212     return 0;
14213   }
14214   {
14215     try {
14216       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14217     } catch (std::out_of_range& e) {
14218       {
14219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14220       };
14221     } catch (std::exception& e) {
14222       {
14223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14224       };
14225     } catch (Dali::DaliException e) {
14226       {
14227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14228       };
14229     } catch (...) {
14230       {
14231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14232       };
14233     }
14234   }
14235
14236   jresult = result;
14237   return jresult;
14238 }
14239
14240
14241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14242   unsigned int jresult ;
14243   unsigned int arg1 ;
14244   unsigned int result;
14245
14246   arg1 = (unsigned int)jarg1;
14247   {
14248     try {
14249       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14250     } catch (std::out_of_range& e) {
14251       {
14252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14253       };
14254     } catch (std::exception& e) {
14255       {
14256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14257       };
14258     } catch (Dali::DaliException e) {
14259       {
14260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14261       };
14262     } catch (...) {
14263       {
14264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14265       };
14266     }
14267   }
14268
14269   jresult = result;
14270   return jresult;
14271 }
14272
14273
14274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14275   unsigned int jresult ;
14276   unsigned int arg1 ;
14277   bool result;
14278
14279   arg1 = (unsigned int)jarg1;
14280   {
14281     try {
14282       result = (bool)Dali::IsPowerOfTwo(arg1);
14283     } catch (std::out_of_range& e) {
14284       {
14285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14286       };
14287     } catch (std::exception& e) {
14288       {
14289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14290       };
14291     } catch (Dali::DaliException e) {
14292       {
14293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14294       };
14295     } catch (...) {
14296       {
14297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14298       };
14299     }
14300   }
14301
14302   jresult = result;
14303   return jresult;
14304 }
14305
14306
14307 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14308   float jresult ;
14309   float arg1 ;
14310   float arg2 ;
14311   float result;
14312
14313   arg1 = (float)jarg1;
14314   arg2 = (float)jarg2;
14315   {
14316     try {
14317       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14318     } catch (std::out_of_range& e) {
14319       {
14320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14321       };
14322     } catch (std::exception& e) {
14323       {
14324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14325       };
14326     } catch (Dali::DaliException e) {
14327       {
14328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14329       };
14330     } catch (...) {
14331       {
14332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14333       };
14334     }
14335   }
14336
14337   jresult = result;
14338   return jresult;
14339 }
14340
14341
14342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14343   unsigned int jresult ;
14344   float arg1 ;
14345   bool result;
14346
14347   arg1 = (float)jarg1;
14348   {
14349     try {
14350       result = (bool)Dali::EqualsZero(arg1);
14351     } catch (std::out_of_range& e) {
14352       {
14353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14354       };
14355     } catch (std::exception& e) {
14356       {
14357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14358       };
14359     } catch (Dali::DaliException e) {
14360       {
14361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14362       };
14363     } catch (...) {
14364       {
14365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14366       };
14367     }
14368   }
14369
14370   jresult = result;
14371   return jresult;
14372 }
14373
14374
14375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14376   unsigned int jresult ;
14377   float arg1 ;
14378   float arg2 ;
14379   bool result;
14380
14381   arg1 = (float)jarg1;
14382   arg2 = (float)jarg2;
14383   {
14384     try {
14385       result = (bool)Dali::Equals(arg1,arg2);
14386     } catch (std::out_of_range& e) {
14387       {
14388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14389       };
14390     } catch (std::exception& e) {
14391       {
14392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14393       };
14394     } catch (Dali::DaliException e) {
14395       {
14396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14397       };
14398     } catch (...) {
14399       {
14400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14401       };
14402     }
14403   }
14404
14405   jresult = result;
14406   return jresult;
14407 }
14408
14409
14410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14411   unsigned int jresult ;
14412   float arg1 ;
14413   float arg2 ;
14414   float arg3 ;
14415   bool result;
14416
14417   arg1 = (float)jarg1;
14418   arg2 = (float)jarg2;
14419   arg3 = (float)jarg3;
14420   {
14421     try {
14422       result = (bool)Dali::Equals(arg1,arg2,arg3);
14423     } catch (std::out_of_range& e) {
14424       {
14425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14426       };
14427     } catch (std::exception& e) {
14428       {
14429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14430       };
14431     } catch (Dali::DaliException e) {
14432       {
14433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14434       };
14435     } catch (...) {
14436       {
14437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14438       };
14439     }
14440   }
14441
14442   jresult = result;
14443   return jresult;
14444 }
14445
14446
14447 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14448   float jresult ;
14449   float arg1 ;
14450   int arg2 ;
14451   float result;
14452
14453   arg1 = (float)jarg1;
14454   arg2 = (int)jarg2;
14455   {
14456     try {
14457       result = (float)Dali::Round(arg1,arg2);
14458     } catch (std::out_of_range& e) {
14459       {
14460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14461       };
14462     } catch (std::exception& e) {
14463       {
14464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14465       };
14466     } catch (Dali::DaliException e) {
14467       {
14468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14469       };
14470     } catch (...) {
14471       {
14472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14473       };
14474     }
14475   }
14476
14477   jresult = result;
14478   return jresult;
14479 }
14480
14481
14482 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14483   float jresult ;
14484   float arg1 ;
14485   float arg2 ;
14486   float arg3 ;
14487   float result;
14488
14489   arg1 = (float)jarg1;
14490   arg2 = (float)jarg2;
14491   arg3 = (float)jarg3;
14492   {
14493     try {
14494       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14495     } catch (std::out_of_range& e) {
14496       {
14497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14498       };
14499     } catch (std::exception& e) {
14500       {
14501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14502       };
14503     } catch (Dali::DaliException e) {
14504       {
14505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14506       };
14507     } catch (...) {
14508       {
14509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14510       };
14511     }
14512   }
14513
14514   jresult = result;
14515   return jresult;
14516 }
14517
14518
14519 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14520   float jresult ;
14521   float arg1 ;
14522   float arg2 ;
14523   float arg3 ;
14524   float arg4 ;
14525   float result;
14526
14527   arg1 = (float)jarg1;
14528   arg2 = (float)jarg2;
14529   arg3 = (float)jarg3;
14530   arg4 = (float)jarg4;
14531   {
14532     try {
14533       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14534     } catch (std::out_of_range& e) {
14535       {
14536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14537       };
14538     } catch (std::exception& e) {
14539       {
14540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14541       };
14542     } catch (Dali::DaliException e) {
14543       {
14544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14545       };
14546     } catch (...) {
14547       {
14548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14549       };
14550     }
14551   }
14552
14553   jresult = result;
14554   return jresult;
14555 }
14556
14557
14558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14559   int jresult ;
14560   int result;
14561
14562   result = (int)(int)Dali::Property::INVALID_INDEX;
14563   jresult = result;
14564   return jresult;
14565 }
14566
14567
14568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14569   int jresult ;
14570   int result;
14571
14572   result = (int)(int)Dali::Property::INVALID_KEY;
14573   jresult = result;
14574   return jresult;
14575 }
14576
14577
14578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14579   int jresult ;
14580   int result;
14581
14582   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14583   jresult = result;
14584   return jresult;
14585 }
14586
14587
14588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14589   void * jresult ;
14590   Dali::Handle *arg1 = 0 ;
14591   Dali::Property::Index arg2 ;
14592   Dali::Property *result = 0 ;
14593
14594   arg1 = (Dali::Handle *)jarg1;
14595   if (!arg1) {
14596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14597     return 0;
14598   }
14599   arg2 = (Dali::Property::Index)jarg2;
14600   {
14601     try {
14602       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14603     } catch (std::out_of_range& e) {
14604       {
14605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14606       };
14607     } catch (std::exception& e) {
14608       {
14609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14610       };
14611     } catch (Dali::DaliException e) {
14612       {
14613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14614       };
14615     } catch (...) {
14616       {
14617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14618       };
14619     }
14620   }
14621
14622   jresult = (void *)result;
14623   return jresult;
14624 }
14625
14626
14627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14628   void * jresult ;
14629   Dali::Handle *arg1 = 0 ;
14630   Dali::Property::Index arg2 ;
14631   int arg3 ;
14632   Dali::Property *result = 0 ;
14633
14634   arg1 = (Dali::Handle *)jarg1;
14635   if (!arg1) {
14636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14637     return 0;
14638   }
14639   arg2 = (Dali::Property::Index)jarg2;
14640   arg3 = (int)jarg3;
14641   {
14642     try {
14643       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14644     } catch (std::out_of_range& e) {
14645       {
14646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14647       };
14648     } catch (std::exception& e) {
14649       {
14650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14651       };
14652     } catch (Dali::DaliException e) {
14653       {
14654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14655       };
14656     } catch (...) {
14657       {
14658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14659       };
14660     }
14661   }
14662
14663   jresult = (void *)result;
14664   return jresult;
14665 }
14666
14667
14668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14669   void * jresult ;
14670   Dali::Handle *arg1 = 0 ;
14671   std::string *arg2 = 0 ;
14672   Dali::Property *result = 0 ;
14673
14674   arg1 = (Dali::Handle *)jarg1;
14675   if (!arg1) {
14676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14677     return 0;
14678   }
14679   if (!jarg2) {
14680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14681     return 0;
14682   }
14683   std::string arg2_str(jarg2);
14684   arg2 = &arg2_str;
14685   {
14686     try {
14687       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14688     } catch (std::out_of_range& e) {
14689       {
14690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14691       };
14692     } catch (std::exception& e) {
14693       {
14694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14695       };
14696     } catch (Dali::DaliException e) {
14697       {
14698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14699       };
14700     } catch (...) {
14701       {
14702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14703       };
14704     }
14705   }
14706
14707   jresult = (void *)result;
14708
14709   //argout typemap for const std::string&
14710
14711   return jresult;
14712 }
14713
14714
14715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14716   void * jresult ;
14717   Dali::Handle *arg1 = 0 ;
14718   std::string *arg2 = 0 ;
14719   int arg3 ;
14720   Dali::Property *result = 0 ;
14721
14722   arg1 = (Dali::Handle *)jarg1;
14723   if (!arg1) {
14724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14725     return 0;
14726   }
14727   if (!jarg2) {
14728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14729     return 0;
14730   }
14731   std::string arg2_str(jarg2);
14732   arg2 = &arg2_str;
14733   arg3 = (int)jarg3;
14734   {
14735     try {
14736       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14737     } catch (std::out_of_range& e) {
14738       {
14739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14740       };
14741     } catch (std::exception& e) {
14742       {
14743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14744       };
14745     } catch (Dali::DaliException e) {
14746       {
14747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14748       };
14749     } catch (...) {
14750       {
14751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14752       };
14753     }
14754   }
14755
14756   jresult = (void *)result;
14757
14758   //argout typemap for const std::string&
14759
14760   return jresult;
14761 }
14762
14763
14764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14765   Dali::Property *arg1 = (Dali::Property *) 0 ;
14766
14767   arg1 = (Dali::Property *)jarg1;
14768   {
14769     try {
14770       delete arg1;
14771     } catch (std::out_of_range& e) {
14772       {
14773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14774       };
14775     } catch (std::exception& e) {
14776       {
14777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14778       };
14779     } catch (Dali::DaliException e) {
14780       {
14781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14782       };
14783     } catch (...) {
14784       {
14785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14786       };
14787     }
14788   }
14789
14790 }
14791
14792
14793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14794   Dali::Property *arg1 = (Dali::Property *) 0 ;
14795   Dali::Handle *arg2 = 0 ;
14796
14797   arg1 = (Dali::Property *)jarg1;
14798   arg2 = (Dali::Handle *)jarg2;
14799   if (!arg2) {
14800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14801     return ;
14802   }
14803   if (arg1) (arg1)->object = *arg2;
14804 }
14805
14806
14807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14808   void * jresult ;
14809   Dali::Property *arg1 = (Dali::Property *) 0 ;
14810   Dali::Handle *result = 0 ;
14811
14812   arg1 = (Dali::Property *)jarg1;
14813   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14814   jresult = (void *)result;
14815   return jresult;
14816 }
14817
14818
14819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14820   Dali::Property *arg1 = (Dali::Property *) 0 ;
14821   Dali::Property::Index arg2 ;
14822
14823   arg1 = (Dali::Property *)jarg1;
14824   arg2 = (Dali::Property::Index)jarg2;
14825   if (arg1) (arg1)->propertyIndex = arg2;
14826 }
14827
14828
14829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14830   int jresult ;
14831   Dali::Property *arg1 = (Dali::Property *) 0 ;
14832   Dali::Property::Index result;
14833
14834   arg1 = (Dali::Property *)jarg1;
14835   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14836   jresult = result;
14837   return jresult;
14838 }
14839
14840
14841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14842   Dali::Property *arg1 = (Dali::Property *) 0 ;
14843   int arg2 ;
14844
14845   arg1 = (Dali::Property *)jarg1;
14846   arg2 = (int)jarg2;
14847   if (arg1) (arg1)->componentIndex = arg2;
14848 }
14849
14850
14851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14852   int jresult ;
14853   Dali::Property *arg1 = (Dali::Property *) 0 ;
14854   int result;
14855
14856   arg1 = (Dali::Property *)jarg1;
14857   result = (int) ((arg1)->componentIndex);
14858   jresult = result;
14859   return jresult;
14860 }
14861
14862
14863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14864   void * jresult ;
14865   Dali::Property::Array *result = 0 ;
14866
14867   {
14868     try {
14869       result = (Dali::Property::Array *)new Dali::Property::Array();
14870     } catch (std::out_of_range& e) {
14871       {
14872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14873       };
14874     } catch (std::exception& e) {
14875       {
14876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14877       };
14878     } catch (Dali::DaliException e) {
14879       {
14880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14881       };
14882     } catch (...) {
14883       {
14884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14885       };
14886     }
14887   }
14888
14889   jresult = (void *)result;
14890   return jresult;
14891 }
14892
14893
14894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14895   void * jresult ;
14896   Dali::Property::Array *arg1 = 0 ;
14897   Dali::Property::Array *result = 0 ;
14898
14899   arg1 = (Dali::Property::Array *)jarg1;
14900   if (!arg1) {
14901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14902     return 0;
14903   }
14904   {
14905     try {
14906       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14907     } catch (std::out_of_range& e) {
14908       {
14909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14910       };
14911     } catch (std::exception& e) {
14912       {
14913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14914       };
14915     } catch (Dali::DaliException e) {
14916       {
14917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14918       };
14919     } catch (...) {
14920       {
14921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14922       };
14923     }
14924   }
14925
14926   jresult = (void *)result;
14927   return jresult;
14928 }
14929
14930
14931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14932   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14933
14934   arg1 = (Dali::Property::Array *)jarg1;
14935   {
14936     try {
14937       delete arg1;
14938     } catch (std::out_of_range& e) {
14939       {
14940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14941       };
14942     } catch (std::exception& e) {
14943       {
14944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14945       };
14946     } catch (Dali::DaliException e) {
14947       {
14948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14949       };
14950     } catch (...) {
14951       {
14952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14953       };
14954     }
14955   }
14956
14957 }
14958
14959
14960 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14961   unsigned long jresult ;
14962   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14963   Dali::Property::Array::SizeType result;
14964
14965   arg1 = (Dali::Property::Array *)jarg1;
14966   {
14967     try {
14968       result = ((Dali::Property::Array const *)arg1)->Size();
14969     } catch (std::out_of_range& e) {
14970       {
14971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14972       };
14973     } catch (std::exception& e) {
14974       {
14975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14976       };
14977     } catch (Dali::DaliException e) {
14978       {
14979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14980       };
14981     } catch (...) {
14982       {
14983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14984       };
14985     }
14986   }
14987
14988   jresult = (unsigned long)result;
14989   return jresult;
14990 }
14991
14992
14993 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
14994   unsigned long jresult ;
14995   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14996   Dali::Property::Array::SizeType result;
14997
14998   arg1 = (Dali::Property::Array *)jarg1;
14999   {
15000     try {
15001       result = ((Dali::Property::Array const *)arg1)->Count();
15002     } catch (std::out_of_range& e) {
15003       {
15004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15005       };
15006     } catch (std::exception& e) {
15007       {
15008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15009       };
15010     } catch (Dali::DaliException e) {
15011       {
15012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15013       };
15014     } catch (...) {
15015       {
15016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15017       };
15018     }
15019   }
15020
15021   jresult = (unsigned long)result;
15022   return jresult;
15023 }
15024
15025
15026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15027   unsigned int jresult ;
15028   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15029   bool result;
15030
15031   arg1 = (Dali::Property::Array *)jarg1;
15032   {
15033     try {
15034       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15035     } catch (std::out_of_range& e) {
15036       {
15037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15038       };
15039     } catch (std::exception& e) {
15040       {
15041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15042       };
15043     } catch (Dali::DaliException e) {
15044       {
15045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15046       };
15047     } catch (...) {
15048       {
15049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15050       };
15051     }
15052   }
15053
15054   jresult = result;
15055   return jresult;
15056 }
15057
15058
15059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15060   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15061
15062   arg1 = (Dali::Property::Array *)jarg1;
15063   {
15064     try {
15065       (arg1)->Clear();
15066     } catch (std::out_of_range& e) {
15067       {
15068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15069       };
15070     } catch (std::exception& e) {
15071       {
15072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15073       };
15074     } catch (Dali::DaliException e) {
15075       {
15076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15077       };
15078     } catch (...) {
15079       {
15080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15081       };
15082     }
15083   }
15084
15085 }
15086
15087
15088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15089   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15090   Dali::Property::Array::SizeType arg2 ;
15091
15092   arg1 = (Dali::Property::Array *)jarg1;
15093   arg2 = (Dali::Property::Array::SizeType)jarg2;
15094   {
15095     try {
15096       (arg1)->Reserve(arg2);
15097     } catch (std::out_of_range& e) {
15098       {
15099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15100       };
15101     } catch (std::exception& e) {
15102       {
15103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15104       };
15105     } catch (Dali::DaliException e) {
15106       {
15107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15108       };
15109     } catch (...) {
15110       {
15111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15112       };
15113     }
15114   }
15115
15116 }
15117
15118
15119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15120   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15121   Dali::Property::Array::SizeType arg2 ;
15122
15123   arg1 = (Dali::Property::Array *)jarg1;
15124   arg2 = (Dali::Property::Array::SizeType)jarg2;
15125   {
15126     try {
15127       (arg1)->Resize(arg2);
15128     } catch (std::out_of_range& e) {
15129       {
15130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15131       };
15132     } catch (std::exception& e) {
15133       {
15134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15135       };
15136     } catch (Dali::DaliException e) {
15137       {
15138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15139       };
15140     } catch (...) {
15141       {
15142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15143       };
15144     }
15145   }
15146
15147 }
15148
15149
15150 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15151   unsigned long jresult ;
15152   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15153   Dali::Property::Array::SizeType result;
15154
15155   arg1 = (Dali::Property::Array *)jarg1;
15156   {
15157     try {
15158       result = (arg1)->Capacity();
15159     } catch (std::out_of_range& e) {
15160       {
15161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15162       };
15163     } catch (std::exception& e) {
15164       {
15165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15166       };
15167     } catch (Dali::DaliException e) {
15168       {
15169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15170       };
15171     } catch (...) {
15172       {
15173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15174       };
15175     }
15176   }
15177
15178   jresult = (unsigned long)result;
15179   return jresult;
15180 }
15181
15182
15183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15184   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15185   Dali::Property::Value *arg2 = 0 ;
15186
15187   arg1 = (Dali::Property::Array *)jarg1;
15188   arg2 = (Dali::Property::Value *)jarg2;
15189   if (!arg2) {
15190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15191     return ;
15192   }
15193   {
15194     try {
15195       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15196     } catch (std::out_of_range& e) {
15197       {
15198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15199       };
15200     } catch (std::exception& e) {
15201       {
15202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15203       };
15204     } catch (Dali::DaliException e) {
15205       {
15206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15207       };
15208     } catch (...) {
15209       {
15210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15211       };
15212     }
15213   }
15214
15215 }
15216
15217
15218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15219   void * jresult ;
15220   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15221   Dali::Property::Value *arg2 = 0 ;
15222   Dali::Property::Array *result = 0 ;
15223
15224   arg1 = (Dali::Property::Array *)jarg1;
15225   arg2 = (Dali::Property::Value *)jarg2;
15226   if (!arg2) {
15227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15228     return 0;
15229   }
15230   {
15231     try {
15232       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15233     } catch (std::out_of_range& e) {
15234       {
15235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15236       };
15237     } catch (std::exception& e) {
15238       {
15239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15240       };
15241     } catch (Dali::DaliException e) {
15242       {
15243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15244       };
15245     } catch (...) {
15246       {
15247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15248       };
15249     }
15250   }
15251
15252   jresult = (void *)result;
15253   return jresult;
15254 }
15255
15256
15257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15258   void * jresult ;
15259   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15260   Dali::Property::Array::SizeType arg2 ;
15261   Dali::Property::Value *result = 0 ;
15262
15263   arg1 = (Dali::Property::Array *)jarg1;
15264   arg2 = (Dali::Property::Array::SizeType)jarg2;
15265   {
15266     try {
15267       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15268     } catch (std::out_of_range& e) {
15269       {
15270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15271       };
15272     } catch (std::exception& e) {
15273       {
15274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15275       };
15276     } catch (Dali::DaliException e) {
15277       {
15278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15279       };
15280     } catch (...) {
15281       {
15282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15283       };
15284     }
15285   }
15286
15287   jresult = (void *)result;
15288   return jresult;
15289 }
15290
15291
15292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15293   void * jresult ;
15294   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15295   Dali::Property::Array::SizeType arg2 ;
15296   Dali::Property::Value *result = 0 ;
15297
15298   arg1 = (Dali::Property::Array *)jarg1;
15299   arg2 = (Dali::Property::Array::SizeType)jarg2;
15300   {
15301     try {
15302       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15303     } catch (std::out_of_range& e) {
15304       {
15305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15306       };
15307     } catch (std::exception& e) {
15308       {
15309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15310       };
15311     } catch (Dali::DaliException e) {
15312       {
15313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15314       };
15315     } catch (...) {
15316       {
15317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15318       };
15319     }
15320   }
15321
15322   jresult = (void *)result;
15323   return jresult;
15324 }
15325
15326
15327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15328   void * jresult ;
15329   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15330   Dali::Property::Array *arg2 = 0 ;
15331   Dali::Property::Array *result = 0 ;
15332
15333   arg1 = (Dali::Property::Array *)jarg1;
15334   arg2 = (Dali::Property::Array *)jarg2;
15335   if (!arg2) {
15336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15337     return 0;
15338   }
15339   {
15340     try {
15341       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15342     } catch (std::out_of_range& e) {
15343       {
15344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15345       };
15346     } catch (std::exception& e) {
15347       {
15348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15349       };
15350     } catch (Dali::DaliException e) {
15351       {
15352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15353       };
15354     } catch (...) {
15355       {
15356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15357       };
15358     }
15359   }
15360
15361   jresult = (void *)result;
15362   return jresult;
15363 }
15364
15365
15366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15367   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15368   enum Dali::Property::Key::Type arg2 ;
15369
15370   arg1 = (Dali::Property::Key *)jarg1;
15371   arg2 = (enum Dali::Property::Key::Type)jarg2;
15372   if (arg1) (arg1)->type = arg2;
15373 }
15374
15375
15376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15377   int jresult ;
15378   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15379   enum Dali::Property::Key::Type result;
15380
15381   arg1 = (Dali::Property::Key *)jarg1;
15382   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15383   jresult = (int)result;
15384   return jresult;
15385 }
15386
15387
15388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15389   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15390   Dali::Property::Index arg2 ;
15391
15392   arg1 = (Dali::Property::Key *)jarg1;
15393   arg2 = (Dali::Property::Index)jarg2;
15394   if (arg1) (arg1)->indexKey = arg2;
15395 }
15396
15397
15398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15399   int jresult ;
15400   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15401   Dali::Property::Index result;
15402
15403   arg1 = (Dali::Property::Key *)jarg1;
15404   result = (Dali::Property::Index) ((arg1)->indexKey);
15405   jresult = result;
15406   return jresult;
15407 }
15408
15409
15410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15411   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15412   std::string *arg2 = 0 ;
15413
15414   arg1 = (Dali::Property::Key *)jarg1;
15415   if (!jarg2) {
15416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15417     return ;
15418   }
15419   std::string arg2_str(jarg2);
15420   arg2 = &arg2_str;
15421   if (arg1) (arg1)->stringKey = *arg2;
15422
15423   //argout typemap for const std::string&
15424
15425 }
15426
15427
15428 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15429   char * jresult ;
15430   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15431   std::string *result = 0 ;
15432
15433   arg1 = (Dali::Property::Key *)jarg1;
15434   result = (std::string *) & ((arg1)->stringKey);
15435   jresult = SWIG_csharp_string_callback(result->c_str());
15436   return jresult;
15437 }
15438
15439
15440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15441   void * jresult ;
15442   std::string *arg1 = 0 ;
15443   Dali::Property::Key *result = 0 ;
15444
15445   if (!jarg1) {
15446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15447     return 0;
15448   }
15449   std::string arg1_str(jarg1);
15450   arg1 = &arg1_str;
15451   {
15452     try {
15453       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15454     } catch (std::out_of_range& e) {
15455       {
15456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15457       };
15458     } catch (std::exception& e) {
15459       {
15460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15461       };
15462     } catch (Dali::DaliException e) {
15463       {
15464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15465       };
15466     } catch (...) {
15467       {
15468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15469       };
15470     }
15471   }
15472
15473   jresult = (void *)result;
15474
15475   //argout typemap for const std::string&
15476
15477   return jresult;
15478 }
15479
15480
15481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15482   void * jresult ;
15483   Dali::Property::Index arg1 ;
15484   Dali::Property::Key *result = 0 ;
15485
15486   arg1 = (Dali::Property::Index)jarg1;
15487   {
15488     try {
15489       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15490     } catch (std::out_of_range& e) {
15491       {
15492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15493       };
15494     } catch (std::exception& e) {
15495       {
15496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15497       };
15498     } catch (Dali::DaliException e) {
15499       {
15500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15501       };
15502     } catch (...) {
15503       {
15504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15505       };
15506     }
15507   }
15508
15509   jresult = (void *)result;
15510   return jresult;
15511 }
15512
15513
15514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15515   unsigned int jresult ;
15516   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15517   std::string *arg2 = 0 ;
15518   bool result;
15519
15520   arg1 = (Dali::Property::Key *)jarg1;
15521   if (!jarg2) {
15522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15523     return 0;
15524   }
15525   std::string arg2_str(jarg2);
15526   arg2 = &arg2_str;
15527   {
15528     try {
15529       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15530     } catch (std::out_of_range& e) {
15531       {
15532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15533       };
15534     } catch (std::exception& e) {
15535       {
15536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15537       };
15538     } catch (Dali::DaliException e) {
15539       {
15540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15541       };
15542     } catch (...) {
15543       {
15544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15545       };
15546     }
15547   }
15548
15549   jresult = result;
15550
15551   //argout typemap for const std::string&
15552
15553   return jresult;
15554 }
15555
15556
15557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15558   unsigned int jresult ;
15559   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15560   Dali::Property::Index arg2 ;
15561   bool result;
15562
15563   arg1 = (Dali::Property::Key *)jarg1;
15564   arg2 = (Dali::Property::Index)jarg2;
15565   {
15566     try {
15567       result = (bool)(arg1)->operator ==(arg2);
15568     } catch (std::out_of_range& e) {
15569       {
15570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15571       };
15572     } catch (std::exception& e) {
15573       {
15574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15575       };
15576     } catch (Dali::DaliException e) {
15577       {
15578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15579       };
15580     } catch (...) {
15581       {
15582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15583       };
15584     }
15585   }
15586
15587   jresult = result;
15588   return jresult;
15589 }
15590
15591
15592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15593   unsigned int jresult ;
15594   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15595   Dali::Property::Key *arg2 = 0 ;
15596   bool result;
15597
15598   arg1 = (Dali::Property::Key *)jarg1;
15599   arg2 = (Dali::Property::Key *)jarg2;
15600   if (!arg2) {
15601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15602     return 0;
15603   }
15604   {
15605     try {
15606       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15607     } catch (std::out_of_range& e) {
15608       {
15609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15610       };
15611     } catch (std::exception& e) {
15612       {
15613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15614       };
15615     } catch (Dali::DaliException e) {
15616       {
15617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15618       };
15619     } catch (...) {
15620       {
15621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15622       };
15623     }
15624   }
15625
15626   jresult = result;
15627   return jresult;
15628 }
15629
15630
15631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15632   unsigned int jresult ;
15633   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15634   std::string *arg2 = 0 ;
15635   bool result;
15636
15637   arg1 = (Dali::Property::Key *)jarg1;
15638   if (!jarg2) {
15639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15640     return 0;
15641   }
15642   std::string arg2_str(jarg2);
15643   arg2 = &arg2_str;
15644   {
15645     try {
15646       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15647     } catch (std::out_of_range& e) {
15648       {
15649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15650       };
15651     } catch (std::exception& e) {
15652       {
15653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15654       };
15655     } catch (Dali::DaliException e) {
15656       {
15657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15658       };
15659     } catch (...) {
15660       {
15661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15662       };
15663     }
15664   }
15665
15666   jresult = result;
15667
15668   //argout typemap for const std::string&
15669
15670   return jresult;
15671 }
15672
15673
15674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15675   unsigned int jresult ;
15676   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15677   Dali::Property::Index arg2 ;
15678   bool result;
15679
15680   arg1 = (Dali::Property::Key *)jarg1;
15681   arg2 = (Dali::Property::Index)jarg2;
15682   {
15683     try {
15684       result = (bool)(arg1)->operator !=(arg2);
15685     } catch (std::out_of_range& e) {
15686       {
15687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15688       };
15689     } catch (std::exception& e) {
15690       {
15691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15692       };
15693     } catch (Dali::DaliException e) {
15694       {
15695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15696       };
15697     } catch (...) {
15698       {
15699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15700       };
15701     }
15702   }
15703
15704   jresult = result;
15705   return jresult;
15706 }
15707
15708
15709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15710   unsigned int jresult ;
15711   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15712   Dali::Property::Key *arg2 = 0 ;
15713   bool result;
15714
15715   arg1 = (Dali::Property::Key *)jarg1;
15716   arg2 = (Dali::Property::Key *)jarg2;
15717   if (!arg2) {
15718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15719     return 0;
15720   }
15721   {
15722     try {
15723       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15724     } catch (std::out_of_range& e) {
15725       {
15726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15727       };
15728     } catch (std::exception& e) {
15729       {
15730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15731       };
15732     } catch (Dali::DaliException e) {
15733       {
15734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15735       };
15736     } catch (...) {
15737       {
15738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15739       };
15740     }
15741   }
15742
15743   jresult = result;
15744   return jresult;
15745 }
15746
15747
15748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15749   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15750
15751   arg1 = (Dali::Property::Key *)jarg1;
15752   {
15753     try {
15754       delete arg1;
15755     } catch (std::out_of_range& e) {
15756       {
15757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15758       };
15759     } catch (std::exception& e) {
15760       {
15761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15762       };
15763     } catch (Dali::DaliException e) {
15764       {
15765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15766       };
15767     } catch (...) {
15768       {
15769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15770       };
15771     }
15772   }
15773
15774 }
15775
15776
15777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15778   void * jresult ;
15779   Dali::Property::Map *result = 0 ;
15780
15781   {
15782     try {
15783       result = (Dali::Property::Map *)new Dali::Property::Map();
15784     } catch (std::out_of_range& e) {
15785       {
15786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15787       };
15788     } catch (std::exception& e) {
15789       {
15790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15791       };
15792     } catch (Dali::DaliException e) {
15793       {
15794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15795       };
15796     } catch (...) {
15797       {
15798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15799       };
15800     }
15801   }
15802
15803   jresult = (void *)result;
15804   return jresult;
15805 }
15806
15807
15808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15809   void * jresult ;
15810   Dali::Property::Map *arg1 = 0 ;
15811   Dali::Property::Map *result = 0 ;
15812
15813   arg1 = (Dali::Property::Map *)jarg1;
15814   if (!arg1) {
15815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15816     return 0;
15817   }
15818   {
15819     try {
15820       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15821     } catch (std::out_of_range& e) {
15822       {
15823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15824       };
15825     } catch (std::exception& e) {
15826       {
15827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15828       };
15829     } catch (Dali::DaliException e) {
15830       {
15831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15832       };
15833     } catch (...) {
15834       {
15835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15836       };
15837     }
15838   }
15839
15840   jresult = (void *)result;
15841   return jresult;
15842 }
15843
15844
15845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15846   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15847
15848   arg1 = (Dali::Property::Map *)jarg1;
15849   {
15850     try {
15851       delete arg1;
15852     } catch (std::out_of_range& e) {
15853       {
15854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15855       };
15856     } catch (std::exception& e) {
15857       {
15858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15859       };
15860     } catch (Dali::DaliException e) {
15861       {
15862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15863       };
15864     } catch (...) {
15865       {
15866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15867       };
15868     }
15869   }
15870
15871 }
15872
15873
15874 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15875   unsigned long jresult ;
15876   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15877   Dali::Property::Map::SizeType result;
15878
15879   arg1 = (Dali::Property::Map *)jarg1;
15880   {
15881     try {
15882       result = ((Dali::Property::Map const *)arg1)->Count();
15883     } catch (std::out_of_range& e) {
15884       {
15885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15886       };
15887     } catch (std::exception& e) {
15888       {
15889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15890       };
15891     } catch (Dali::DaliException e) {
15892       {
15893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15894       };
15895     } catch (...) {
15896       {
15897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15898       };
15899     }
15900   }
15901
15902   jresult = (unsigned long)result;
15903   return jresult;
15904 }
15905
15906
15907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15908   unsigned int jresult ;
15909   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15910   bool result;
15911
15912   arg1 = (Dali::Property::Map *)jarg1;
15913   {
15914     try {
15915       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15916     } catch (std::out_of_range& e) {
15917       {
15918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15919       };
15920     } catch (std::exception& e) {
15921       {
15922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15923       };
15924     } catch (Dali::DaliException e) {
15925       {
15926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15927       };
15928     } catch (...) {
15929       {
15930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15931       };
15932     }
15933   }
15934
15935   jresult = result;
15936   return jresult;
15937 }
15938
15939
15940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15941   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15942   char *arg2 = (char *) 0 ;
15943   Dali::Property::Value *arg3 = 0 ;
15944
15945   arg1 = (Dali::Property::Map *)jarg1;
15946   arg2 = (char *)jarg2;
15947   arg3 = (Dali::Property::Value *)jarg3;
15948   if (!arg3) {
15949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15950     return ;
15951   }
15952   {
15953     try {
15954       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15955     } catch (std::out_of_range& e) {
15956       {
15957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15958       };
15959     } catch (std::exception& e) {
15960       {
15961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15962       };
15963     } catch (Dali::DaliException e) {
15964       {
15965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15966       };
15967     } catch (...) {
15968       {
15969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15970       };
15971     }
15972   }
15973
15974 }
15975
15976
15977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15978   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15979   Dali::Property::Index arg2 ;
15980   Dali::Property::Value *arg3 = 0 ;
15981
15982   arg1 = (Dali::Property::Map *)jarg1;
15983   arg2 = (Dali::Property::Index)jarg2;
15984   arg3 = (Dali::Property::Value *)jarg3;
15985   if (!arg3) {
15986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15987     return ;
15988   }
15989   {
15990     try {
15991       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
15992     } catch (std::out_of_range& e) {
15993       {
15994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15995       };
15996     } catch (std::exception& e) {
15997       {
15998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15999       };
16000     } catch (Dali::DaliException e) {
16001       {
16002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16003       };
16004     } catch (...) {
16005       {
16006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16007       };
16008     }
16009   }
16010
16011 }
16012
16013
16014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16015   void * jresult ;
16016   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16017   char *arg2 = (char *) 0 ;
16018   Dali::Property::Value *arg3 = 0 ;
16019   Dali::Property::Map *result = 0 ;
16020
16021   arg1 = (Dali::Property::Map *)jarg1;
16022   arg2 = (char *)jarg2;
16023   arg3 = (Dali::Property::Value *)jarg3;
16024   if (!arg3) {
16025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16026     return 0;
16027   }
16028   {
16029     try {
16030       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16031     } catch (std::out_of_range& e) {
16032       {
16033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16034       };
16035     } catch (std::exception& e) {
16036       {
16037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16038       };
16039     } catch (Dali::DaliException e) {
16040       {
16041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16042       };
16043     } catch (...) {
16044       {
16045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16046       };
16047     }
16048   }
16049
16050   jresult = (void *)result;
16051   return jresult;
16052 }
16053
16054
16055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16056   void * jresult ;
16057   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16058   Dali::Property::Index arg2 ;
16059   Dali::Property::Value *arg3 = 0 ;
16060   Dali::Property::Map *result = 0 ;
16061
16062   arg1 = (Dali::Property::Map *)jarg1;
16063   arg2 = (Dali::Property::Index)jarg2;
16064   arg3 = (Dali::Property::Value *)jarg3;
16065   if (!arg3) {
16066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16067     return 0;
16068   }
16069   {
16070     try {
16071       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16072     } catch (std::out_of_range& e) {
16073       {
16074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16075       };
16076     } catch (std::exception& e) {
16077       {
16078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16079       };
16080     } catch (Dali::DaliException e) {
16081       {
16082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16083       };
16084     } catch (...) {
16085       {
16086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16087       };
16088     }
16089   }
16090
16091   jresult = (void *)result;
16092   return jresult;
16093 }
16094
16095
16096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16097   void * jresult ;
16098   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16099   Dali::Property::Map::SizeType arg2 ;
16100   Dali::Property::Value *result = 0 ;
16101
16102   arg1 = (Dali::Property::Map *)jarg1;
16103   arg2 = (Dali::Property::Map::SizeType)jarg2;
16104   {
16105     try {
16106       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16107     } catch (std::out_of_range& e) {
16108       {
16109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16110       };
16111     } catch (std::exception& e) {
16112       {
16113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16114       };
16115     } catch (Dali::DaliException e) {
16116       {
16117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16118       };
16119     } catch (...) {
16120       {
16121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16122       };
16123     }
16124   }
16125
16126   jresult = (void *)result;
16127   return jresult;
16128 }
16129
16130
16131 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16132   char * jresult ;
16133   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16134   Dali::Property::Map::SizeType arg2 ;
16135   std::string *result = 0 ;
16136
16137   arg1 = (Dali::Property::Map *)jarg1;
16138   arg2 = (Dali::Property::Map::SizeType)jarg2;
16139   {
16140     try {
16141       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16142     } catch (std::out_of_range& e) {
16143       {
16144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16145       };
16146     } catch (std::exception& e) {
16147       {
16148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16149       };
16150     } catch (Dali::DaliException e) {
16151       {
16152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16153       };
16154     } catch (...) {
16155       {
16156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16157       };
16158     }
16159   }
16160
16161   jresult = SWIG_csharp_string_callback(result->c_str());
16162   return jresult;
16163 }
16164
16165
16166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16167   void * jresult ;
16168   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16169   Dali::Property::Map::SizeType arg2 ;
16170   SwigValueWrapper< Dali::Property::Key > result;
16171
16172   arg1 = (Dali::Property::Map *)jarg1;
16173   arg2 = (Dali::Property::Map::SizeType)jarg2;
16174   {
16175     try {
16176       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16177     } catch (std::out_of_range& e) {
16178       {
16179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16180       };
16181     } catch (std::exception& e) {
16182       {
16183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16184       };
16185     } catch (Dali::DaliException e) {
16186       {
16187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16188       };
16189     } catch (...) {
16190       {
16191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16192       };
16193     }
16194   }
16195
16196   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16197   return jresult;
16198 }
16199
16200
16201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16202   void * jresult ;
16203   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16204   Dali::Property::Map::SizeType arg2 ;
16205   StringValuePair *result = 0 ;
16206
16207   arg1 = (Dali::Property::Map *)jarg1;
16208   arg2 = (Dali::Property::Map::SizeType)jarg2;
16209   {
16210     try {
16211       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16212     } catch (std::out_of_range& e) {
16213       {
16214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16215       };
16216     } catch (std::exception& e) {
16217       {
16218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16219       };
16220     } catch (Dali::DaliException e) {
16221       {
16222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16223       };
16224     } catch (...) {
16225       {
16226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16227       };
16228     }
16229   }
16230
16231   jresult = (void *)result;
16232   return jresult;
16233 }
16234
16235
16236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16237   void * jresult ;
16238   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16239   char *arg2 = (char *) 0 ;
16240   Dali::Property::Value *result = 0 ;
16241
16242   arg1 = (Dali::Property::Map *)jarg1;
16243   arg2 = (char *)jarg2;
16244   {
16245     try {
16246       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16247     } catch (std::out_of_range& e) {
16248       {
16249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16250       };
16251     } catch (std::exception& e) {
16252       {
16253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16254       };
16255     } catch (Dali::DaliException e) {
16256       {
16257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16258       };
16259     } catch (...) {
16260       {
16261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16262       };
16263     }
16264   }
16265
16266   jresult = (void *)result;
16267   return jresult;
16268 }
16269
16270
16271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16272   void * jresult ;
16273   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16274   Dali::Property::Index arg2 ;
16275   Dali::Property::Value *result = 0 ;
16276
16277   arg1 = (Dali::Property::Map *)jarg1;
16278   arg2 = (Dali::Property::Index)jarg2;
16279   {
16280     try {
16281       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16282     } catch (std::out_of_range& e) {
16283       {
16284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16285       };
16286     } catch (std::exception& e) {
16287       {
16288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16289       };
16290     } catch (Dali::DaliException e) {
16291       {
16292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16293       };
16294     } catch (...) {
16295       {
16296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16297       };
16298     }
16299   }
16300
16301   jresult = (void *)result;
16302   return jresult;
16303 }
16304
16305
16306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16307   void * jresult ;
16308   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16309   Dali::Property::Index arg2 ;
16310   std::string *arg3 = 0 ;
16311   Dali::Property::Value *result = 0 ;
16312
16313   arg1 = (Dali::Property::Map *)jarg1;
16314   arg2 = (Dali::Property::Index)jarg2;
16315   if (!jarg3) {
16316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16317     return 0;
16318   }
16319   std::string arg3_str(jarg3);
16320   arg3 = &arg3_str;
16321   {
16322     try {
16323       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16324     } catch (std::out_of_range& e) {
16325       {
16326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16327       };
16328     } catch (std::exception& e) {
16329       {
16330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16331       };
16332     } catch (Dali::DaliException e) {
16333       {
16334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16335       };
16336     } catch (...) {
16337       {
16338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16339       };
16340     }
16341   }
16342
16343   jresult = (void *)result;
16344
16345   //argout typemap for const std::string&
16346
16347   return jresult;
16348 }
16349
16350
16351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16352   void * jresult ;
16353   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16354   std::string *arg2 = 0 ;
16355   Dali::Property::Type arg3 ;
16356   Dali::Property::Value *result = 0 ;
16357
16358   arg1 = (Dali::Property::Map *)jarg1;
16359   if (!jarg2) {
16360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16361     return 0;
16362   }
16363   std::string arg2_str(jarg2);
16364   arg2 = &arg2_str;
16365   arg3 = (Dali::Property::Type)jarg3;
16366   {
16367     try {
16368       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16369     } catch (std::out_of_range& e) {
16370       {
16371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16372       };
16373     } catch (std::exception& e) {
16374       {
16375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16376       };
16377     } catch (Dali::DaliException e) {
16378       {
16379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16380       };
16381     } catch (...) {
16382       {
16383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16384       };
16385     }
16386   }
16387
16388   jresult = (void *)result;
16389
16390   //argout typemap for const std::string&
16391
16392   return jresult;
16393 }
16394
16395
16396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16397   void * jresult ;
16398   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16399   Dali::Property::Index arg2 ;
16400   Dali::Property::Type arg3 ;
16401   Dali::Property::Value *result = 0 ;
16402
16403   arg1 = (Dali::Property::Map *)jarg1;
16404   arg2 = (Dali::Property::Index)jarg2;
16405   arg3 = (Dali::Property::Type)jarg3;
16406   {
16407     try {
16408       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16409     } catch (std::out_of_range& e) {
16410       {
16411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16412       };
16413     } catch (std::exception& e) {
16414       {
16415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16416       };
16417     } catch (Dali::DaliException e) {
16418       {
16419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16420       };
16421     } catch (...) {
16422       {
16423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16424       };
16425     }
16426   }
16427
16428   jresult = (void *)result;
16429   return jresult;
16430 }
16431
16432
16433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16434   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16435
16436   arg1 = (Dali::Property::Map *)jarg1;
16437   {
16438     try {
16439       (arg1)->Clear();
16440     } catch (std::out_of_range& e) {
16441       {
16442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16443       };
16444     } catch (std::exception& e) {
16445       {
16446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16447       };
16448     } catch (Dali::DaliException e) {
16449       {
16450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16451       };
16452     } catch (...) {
16453       {
16454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16455       };
16456     }
16457   }
16458
16459 }
16460
16461
16462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16463   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16464   Dali::Property::Map *arg2 = 0 ;
16465
16466   arg1 = (Dali::Property::Map *)jarg1;
16467   arg2 = (Dali::Property::Map *)jarg2;
16468   if (!arg2) {
16469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16470     return ;
16471   }
16472   {
16473     try {
16474       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16475     } catch (std::out_of_range& e) {
16476       {
16477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16478       };
16479     } catch (std::exception& e) {
16480       {
16481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16482       };
16483     } catch (Dali::DaliException e) {
16484       {
16485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16486       };
16487     } catch (...) {
16488       {
16489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16490       };
16491     }
16492   }
16493
16494 }
16495
16496
16497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16498   void * jresult ;
16499   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16500   std::string *arg2 = 0 ;
16501   Dali::Property::Value *result = 0 ;
16502
16503   arg1 = (Dali::Property::Map *)jarg1;
16504   if (!jarg2) {
16505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16506     return 0;
16507   }
16508   std::string arg2_str(jarg2);
16509   arg2 = &arg2_str;
16510   {
16511     try {
16512       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16513     } catch (std::out_of_range& e) {
16514       {
16515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16516       };
16517     } catch (std::exception& e) {
16518       {
16519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16520       };
16521     } catch (Dali::DaliException e) {
16522       {
16523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16524       };
16525     } catch (...) {
16526       {
16527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16528       };
16529     }
16530   }
16531
16532   jresult = (void *)result;
16533
16534   //argout typemap for const std::string&
16535
16536   return jresult;
16537 }
16538
16539
16540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16541   void * jresult ;
16542   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16543   Dali::Property::Index arg2 ;
16544   Dali::Property::Value *result = 0 ;
16545
16546   arg1 = (Dali::Property::Map *)jarg1;
16547   arg2 = (Dali::Property::Index)jarg2;
16548   {
16549     try {
16550       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16551     } catch (std::out_of_range& e) {
16552       {
16553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16554       };
16555     } catch (std::exception& e) {
16556       {
16557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16558       };
16559     } catch (Dali::DaliException e) {
16560       {
16561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16562       };
16563     } catch (...) {
16564       {
16565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16566       };
16567     }
16568   }
16569
16570   jresult = (void *)result;
16571   return jresult;
16572 }
16573
16574
16575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16576   void * jresult ;
16577   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16578   Dali::Property::Map *arg2 = 0 ;
16579   Dali::Property::Map *result = 0 ;
16580
16581   arg1 = (Dali::Property::Map *)jarg1;
16582   arg2 = (Dali::Property::Map *)jarg2;
16583   if (!arg2) {
16584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16585     return 0;
16586   }
16587   {
16588     try {
16589       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16590     } catch (std::out_of_range& e) {
16591       {
16592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16593       };
16594     } catch (std::exception& e) {
16595       {
16596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16597       };
16598     } catch (Dali::DaliException e) {
16599       {
16600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16601       };
16602     } catch (...) {
16603       {
16604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16605       };
16606     }
16607   }
16608
16609   jresult = (void *)result;
16610   return jresult;
16611 }
16612
16613
16614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
16615
16616   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16617
16618   if (!jarg2) {
16619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16620     return;
16621   }
16622   std::string arg2_str(jarg2);
16623   std::string* arg2 = &arg2_str;
16624
16625   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16626
16627   {
16628     try {
16629       arg1->operator[]((std::string const &)*arg2) = *arg3;
16630     } catch (std::out_of_range& e) {
16631       {
16632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16633       };
16634     } catch (std::exception& e) {
16635       {
16636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16637       };
16638     } catch (Dali::DaliException e) {
16639       {
16640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16641       };
16642     } catch (...) {
16643       {
16644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16645       };
16646     }
16647   }
16648 }
16649
16650
16651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
16652
16653   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16654   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
16655   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16656
16657   {
16658     try {
16659       arg1->operator[](arg2) = *arg3;
16660     } catch (std::out_of_range& e) {
16661       {
16662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16663       };
16664     } catch (std::exception& e) {
16665       {
16666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16667       };
16668     } catch (Dali::DaliException e) {
16669       {
16670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16671       };
16672     } catch (...) {
16673       {
16674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16675       };
16676     }
16677   }
16678 }
16679
16680
16681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16682   void * jresult ;
16683   Dali::Property::Value *result = 0 ;
16684
16685   {
16686     try {
16687       result = (Dali::Property::Value *)new Dali::Property::Value();
16688     } catch (std::out_of_range& e) {
16689       {
16690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16691       };
16692     } catch (std::exception& e) {
16693       {
16694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16695       };
16696     } catch (Dali::DaliException e) {
16697       {
16698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16699       };
16700     } catch (...) {
16701       {
16702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16703       };
16704     }
16705   }
16706
16707   jresult = (void *)result;
16708   return jresult;
16709 }
16710
16711
16712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16713   void * jresult ;
16714   bool arg1 ;
16715   Dali::Property::Value *result = 0 ;
16716
16717   arg1 = jarg1 ? true : false;
16718   {
16719     try {
16720       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16721     } catch (std::out_of_range& e) {
16722       {
16723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16724       };
16725     } catch (std::exception& e) {
16726       {
16727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16728       };
16729     } catch (Dali::DaliException e) {
16730       {
16731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16732       };
16733     } catch (...) {
16734       {
16735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16736       };
16737     }
16738   }
16739
16740   jresult = (void *)result;
16741   return jresult;
16742 }
16743
16744
16745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16746   void * jresult ;
16747   int arg1 ;
16748   Dali::Property::Value *result = 0 ;
16749
16750   arg1 = (int)jarg1;
16751   {
16752     try {
16753       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16754     } catch (std::out_of_range& e) {
16755       {
16756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16757       };
16758     } catch (std::exception& e) {
16759       {
16760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16761       };
16762     } catch (Dali::DaliException e) {
16763       {
16764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16765       };
16766     } catch (...) {
16767       {
16768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16769       };
16770     }
16771   }
16772
16773   jresult = (void *)result;
16774   return jresult;
16775 }
16776
16777
16778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16779   void * jresult ;
16780   float arg1 ;
16781   Dali::Property::Value *result = 0 ;
16782
16783   arg1 = (float)jarg1;
16784   {
16785     try {
16786       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16787     } catch (std::out_of_range& e) {
16788       {
16789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16790       };
16791     } catch (std::exception& e) {
16792       {
16793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16794       };
16795     } catch (Dali::DaliException e) {
16796       {
16797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16798       };
16799     } catch (...) {
16800       {
16801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16802       };
16803     }
16804   }
16805
16806   jresult = (void *)result;
16807   return jresult;
16808 }
16809
16810
16811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16812   void * jresult ;
16813   Dali::Vector2 *arg1 = 0 ;
16814   Dali::Property::Value *result = 0 ;
16815
16816   arg1 = (Dali::Vector2 *)jarg1;
16817   if (!arg1) {
16818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16819     return 0;
16820   }
16821   {
16822     try {
16823       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16824     } catch (std::out_of_range& e) {
16825       {
16826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16827       };
16828     } catch (std::exception& e) {
16829       {
16830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16831       };
16832     } catch (Dali::DaliException e) {
16833       {
16834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16835       };
16836     } catch (...) {
16837       {
16838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16839       };
16840     }
16841   }
16842
16843   jresult = (void *)result;
16844   return jresult;
16845 }
16846
16847
16848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16849   void * jresult ;
16850   Dali::Vector3 *arg1 = 0 ;
16851   Dali::Property::Value *result = 0 ;
16852
16853   arg1 = (Dali::Vector3 *)jarg1;
16854   if (!arg1) {
16855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16856     return 0;
16857   }
16858   {
16859     try {
16860       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16861     } catch (std::out_of_range& e) {
16862       {
16863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16864       };
16865     } catch (std::exception& e) {
16866       {
16867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16868       };
16869     } catch (Dali::DaliException e) {
16870       {
16871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16872       };
16873     } catch (...) {
16874       {
16875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16876       };
16877     }
16878   }
16879
16880   jresult = (void *)result;
16881   return jresult;
16882 }
16883
16884
16885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16886   void * jresult ;
16887   Dali::Vector4 *arg1 = 0 ;
16888   Dali::Property::Value *result = 0 ;
16889
16890   arg1 = (Dali::Vector4 *)jarg1;
16891   if (!arg1) {
16892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16893     return 0;
16894   }
16895   {
16896     try {
16897       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16898     } catch (std::out_of_range& e) {
16899       {
16900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16901       };
16902     } catch (std::exception& e) {
16903       {
16904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16905       };
16906     } catch (Dali::DaliException e) {
16907       {
16908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16909       };
16910     } catch (...) {
16911       {
16912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16913       };
16914     }
16915   }
16916
16917   jresult = (void *)result;
16918   return jresult;
16919 }
16920
16921
16922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16923   void * jresult ;
16924   Dali::Matrix3 *arg1 = 0 ;
16925   Dali::Property::Value *result = 0 ;
16926
16927   arg1 = (Dali::Matrix3 *)jarg1;
16928   if (!arg1) {
16929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16930     return 0;
16931   }
16932   {
16933     try {
16934       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16935     } catch (std::out_of_range& e) {
16936       {
16937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16938       };
16939     } catch (std::exception& e) {
16940       {
16941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16942       };
16943     } catch (Dali::DaliException e) {
16944       {
16945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16946       };
16947     } catch (...) {
16948       {
16949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16950       };
16951     }
16952   }
16953
16954   jresult = (void *)result;
16955   return jresult;
16956 }
16957
16958
16959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16960   void * jresult ;
16961   Dali::Matrix *arg1 = 0 ;
16962   Dali::Property::Value *result = 0 ;
16963
16964   arg1 = (Dali::Matrix *)jarg1;
16965   if (!arg1) {
16966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16967     return 0;
16968   }
16969   {
16970     try {
16971       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16972     } catch (std::out_of_range& e) {
16973       {
16974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16975       };
16976     } catch (std::exception& e) {
16977       {
16978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16979       };
16980     } catch (Dali::DaliException e) {
16981       {
16982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16983       };
16984     } catch (...) {
16985       {
16986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16987       };
16988     }
16989   }
16990
16991   jresult = (void *)result;
16992   return jresult;
16993 }
16994
16995
16996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16997   void * jresult ;
16998   Dali::Rect< int > *arg1 = 0 ;
16999   Dali::Property::Value *result = 0 ;
17000
17001   arg1 = (Dali::Rect< int > *)jarg1;
17002   if (!arg1) {
17003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
17004     return 0;
17005   }
17006   {
17007     try {
17008       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
17009     } catch (std::out_of_range& e) {
17010       {
17011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17012       };
17013     } catch (std::exception& e) {
17014       {
17015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17016       };
17017     } catch (Dali::DaliException e) {
17018       {
17019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17020       };
17021     } catch (...) {
17022       {
17023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17024       };
17025     }
17026   }
17027
17028   jresult = (void *)result;
17029   return jresult;
17030 }
17031
17032
17033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17034   void * jresult ;
17035   Dali::AngleAxis *arg1 = 0 ;
17036   Dali::Property::Value *result = 0 ;
17037
17038   arg1 = (Dali::AngleAxis *)jarg1;
17039   if (!arg1) {
17040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17041     return 0;
17042   }
17043   {
17044     try {
17045       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17046     } catch (std::out_of_range& e) {
17047       {
17048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17049       };
17050     } catch (std::exception& e) {
17051       {
17052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17053       };
17054     } catch (Dali::DaliException e) {
17055       {
17056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17057       };
17058     } catch (...) {
17059       {
17060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17061       };
17062     }
17063   }
17064
17065   jresult = (void *)result;
17066   return jresult;
17067 }
17068
17069
17070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17071   void * jresult ;
17072   Dali::Quaternion *arg1 = 0 ;
17073   Dali::Property::Value *result = 0 ;
17074
17075   arg1 = (Dali::Quaternion *)jarg1;
17076   if (!arg1) {
17077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17078     return 0;
17079   }
17080   {
17081     try {
17082       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17083     } catch (std::out_of_range& e) {
17084       {
17085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17086       };
17087     } catch (std::exception& e) {
17088       {
17089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17090       };
17091     } catch (Dali::DaliException e) {
17092       {
17093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17094       };
17095     } catch (...) {
17096       {
17097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17098       };
17099     }
17100   }
17101
17102   jresult = (void *)result;
17103   return jresult;
17104 }
17105
17106
17107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17108   void * jresult ;
17109   std::string *arg1 = 0 ;
17110   Dali::Property::Value *result = 0 ;
17111
17112   if (!jarg1) {
17113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17114     return 0;
17115   }
17116   std::string arg1_str(jarg1);
17117   arg1 = &arg1_str;
17118   {
17119     try {
17120       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17121     } catch (std::out_of_range& e) {
17122       {
17123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17124       };
17125     } catch (std::exception& e) {
17126       {
17127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17128       };
17129     } catch (Dali::DaliException e) {
17130       {
17131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17132       };
17133     } catch (...) {
17134       {
17135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17136       };
17137     }
17138   }
17139
17140   jresult = (void *)result;
17141
17142   //argout typemap for const std::string&
17143
17144   return jresult;
17145 }
17146
17147
17148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17149   void * jresult ;
17150   Dali::Property::Array *arg1 = 0 ;
17151   Dali::Property::Value *result = 0 ;
17152
17153   arg1 = (Dali::Property::Array *)jarg1;
17154   if (!arg1) {
17155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17156     return 0;
17157   }
17158   {
17159     try {
17160       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17161     } catch (std::out_of_range& e) {
17162       {
17163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17164       };
17165     } catch (std::exception& e) {
17166       {
17167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17168       };
17169     } catch (Dali::DaliException e) {
17170       {
17171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17172       };
17173     } catch (...) {
17174       {
17175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17176       };
17177     }
17178   }
17179
17180   jresult = (void *)result;
17181   return jresult;
17182 }
17183
17184
17185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17186   void * jresult ;
17187   Dali::Property::Map *arg1 = 0 ;
17188   Dali::Property::Value *result = 0 ;
17189
17190   arg1 = (Dali::Property::Map *)jarg1;
17191   if (!arg1) {
17192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17193     return 0;
17194   }
17195   {
17196     try {
17197       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17198     } catch (std::out_of_range& e) {
17199       {
17200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17201       };
17202     } catch (std::exception& e) {
17203       {
17204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17205       };
17206     } catch (Dali::DaliException e) {
17207       {
17208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17209       };
17210     } catch (...) {
17211       {
17212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17213       };
17214     }
17215   }
17216
17217   jresult = (void *)result;
17218   return jresult;
17219 }
17220
17221
17222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17223   void * jresult ;
17224   Extents *arg1 = 0 ;
17225   Dali::Property::Value *result = 0 ;
17226
17227   arg1 = (Extents *)jarg1;
17228   if (!arg1) {
17229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17230     return 0;
17231   }
17232   {
17233     try {
17234       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17235     } catch (std::out_of_range& e) {
17236       {
17237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17238       };
17239     } catch (std::exception& e) {
17240       {
17241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17242       };
17243     } catch (...) {
17244       {
17245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17246       };
17247     }
17248   }
17249   jresult = (void *)result;
17250   return jresult;
17251 }
17252
17253
17254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17255   void * jresult ;
17256   Dali::Property::Type arg1 ;
17257   Dali::Property::Value *result = 0 ;
17258
17259   arg1 = (Dali::Property::Type)jarg1;
17260   {
17261     try {
17262       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17263     } catch (std::out_of_range& e) {
17264       {
17265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17266       };
17267     } catch (std::exception& e) {
17268       {
17269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17270       };
17271     } catch (Dali::DaliException e) {
17272       {
17273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17274       };
17275     } catch (...) {
17276       {
17277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17278       };
17279     }
17280   }
17281
17282   jresult = (void *)result;
17283   return jresult;
17284 }
17285
17286
17287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17288   void * jresult ;
17289   Dali::Property::Value *arg1 = 0 ;
17290   Dali::Property::Value *result = 0 ;
17291
17292   arg1 = (Dali::Property::Value *)jarg1;
17293   if (!arg1) {
17294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17295     return 0;
17296   }
17297   {
17298     try {
17299       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17300     } catch (std::out_of_range& e) {
17301       {
17302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17303       };
17304     } catch (std::exception& e) {
17305       {
17306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17307       };
17308     } catch (Dali::DaliException e) {
17309       {
17310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17311       };
17312     } catch (...) {
17313       {
17314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17315       };
17316     }
17317   }
17318
17319   jresult = (void *)result;
17320   return jresult;
17321 }
17322
17323
17324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17325   void * jresult ;
17326   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17327   Dali::Property::Value *arg2 = 0 ;
17328   Dali::Property::Value *result = 0 ;
17329
17330   arg1 = (Dali::Property::Value *)jarg1;
17331   arg2 = (Dali::Property::Value *)jarg2;
17332   if (!arg2) {
17333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17334     return 0;
17335   }
17336   {
17337     try {
17338       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17339     } catch (std::out_of_range& e) {
17340       {
17341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17342       };
17343     } catch (std::exception& e) {
17344       {
17345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17346       };
17347     } catch (Dali::DaliException e) {
17348       {
17349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17350       };
17351     } catch (...) {
17352       {
17353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17354       };
17355     }
17356   }
17357
17358   jresult = (void *)result;
17359   return jresult;
17360 }
17361
17362
17363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17364   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17365
17366   arg1 = (Dali::Property::Value *)jarg1;
17367   {
17368     try {
17369       delete arg1;
17370     } catch (std::out_of_range& e) {
17371       {
17372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17373       };
17374     } catch (std::exception& e) {
17375       {
17376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17377       };
17378     } catch (Dali::DaliException e) {
17379       {
17380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17381       };
17382     } catch (...) {
17383       {
17384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17385       };
17386     }
17387   }
17388
17389 }
17390
17391
17392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17393   int jresult ;
17394   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17395   Dali::Property::Type result;
17396
17397   arg1 = (Dali::Property::Value *)jarg1;
17398   {
17399     try {
17400       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17401     } catch (std::out_of_range& e) {
17402       {
17403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17404       };
17405     } catch (std::exception& e) {
17406       {
17407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17408       };
17409     } catch (Dali::DaliException e) {
17410       {
17411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17412       };
17413     } catch (...) {
17414       {
17415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17416       };
17417     }
17418   }
17419
17420   jresult = (int)result;
17421   return jresult;
17422 }
17423
17424
17425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17426   unsigned int jresult ;
17427   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17428   bool *arg2 = 0 ;
17429   bool result;
17430
17431   arg1 = (Dali::Property::Value *)jarg1;
17432   arg2 = (bool *)jarg2;
17433   {
17434     try {
17435       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17436     } catch (std::out_of_range& e) {
17437       {
17438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17439       };
17440     } catch (std::exception& e) {
17441       {
17442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17443       };
17444     } catch (Dali::DaliException e) {
17445       {
17446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17447       };
17448     } catch (...) {
17449       {
17450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17451       };
17452     }
17453   }
17454
17455   jresult = result;
17456   return jresult;
17457 }
17458
17459
17460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17461   unsigned int jresult ;
17462   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17463   float *arg2 = 0 ;
17464   bool result;
17465
17466   arg1 = (Dali::Property::Value *)jarg1;
17467   arg2 = (float *)jarg2;
17468   {
17469     try {
17470       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17471     } catch (std::out_of_range& e) {
17472       {
17473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17474       };
17475     } catch (std::exception& e) {
17476       {
17477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17478       };
17479     } catch (Dali::DaliException e) {
17480       {
17481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17482       };
17483     } catch (...) {
17484       {
17485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17486       };
17487     }
17488   }
17489
17490   jresult = result;
17491   return jresult;
17492 }
17493
17494
17495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17496   unsigned int jresult ;
17497   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17498   int *arg2 = 0 ;
17499   bool result;
17500
17501   arg1 = (Dali::Property::Value *)jarg1;
17502   arg2 = (int *)jarg2;
17503   {
17504     try {
17505       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17506     } catch (std::out_of_range& e) {
17507       {
17508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17509       };
17510     } catch (std::exception& e) {
17511       {
17512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17513       };
17514     } catch (Dali::DaliException e) {
17515       {
17516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17517       };
17518     } catch (...) {
17519       {
17520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17521       };
17522     }
17523   }
17524
17525   jresult = result;
17526   return jresult;
17527 }
17528
17529
17530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17531   unsigned int jresult ;
17532   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17533   Dali::Rect< int > *arg2 = 0 ;
17534   bool result;
17535
17536   arg1 = (Dali::Property::Value *)jarg1;
17537   arg2 = (Dali::Rect< int > *)jarg2;
17538   if (!arg2) {
17539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17540     return 0;
17541   }
17542   {
17543     try {
17544       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17545     } catch (std::out_of_range& e) {
17546       {
17547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17548       };
17549     } catch (std::exception& e) {
17550       {
17551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17552       };
17553     } catch (Dali::DaliException e) {
17554       {
17555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17556       };
17557     } catch (...) {
17558       {
17559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17560       };
17561     }
17562   }
17563
17564   jresult = result;
17565   return jresult;
17566 }
17567
17568
17569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17570   unsigned int jresult ;
17571   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17572   Dali::Vector2 *arg2 = 0 ;
17573   bool result;
17574
17575   arg1 = (Dali::Property::Value *)jarg1;
17576   arg2 = (Dali::Vector2 *)jarg2;
17577   if (!arg2) {
17578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17579     return 0;
17580   }
17581   {
17582     try {
17583       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17584     } catch (std::out_of_range& e) {
17585       {
17586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17587       };
17588     } catch (std::exception& e) {
17589       {
17590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17591       };
17592     } catch (Dali::DaliException e) {
17593       {
17594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17595       };
17596     } catch (...) {
17597       {
17598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17599       };
17600     }
17601   }
17602
17603   jresult = result;
17604   return jresult;
17605 }
17606
17607
17608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17609   unsigned int jresult ;
17610   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17611   Dali::Vector3 *arg2 = 0 ;
17612   bool result;
17613
17614   arg1 = (Dali::Property::Value *)jarg1;
17615   arg2 = (Dali::Vector3 *)jarg2;
17616   if (!arg2) {
17617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17618     return 0;
17619   }
17620   {
17621     try {
17622       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17623     } catch (std::out_of_range& e) {
17624       {
17625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17626       };
17627     } catch (std::exception& e) {
17628       {
17629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17630       };
17631     } catch (Dali::DaliException e) {
17632       {
17633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17634       };
17635     } catch (...) {
17636       {
17637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17638       };
17639     }
17640   }
17641
17642   jresult = result;
17643   return jresult;
17644 }
17645
17646
17647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17648   unsigned int jresult ;
17649   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17650   Dali::Vector4 *arg2 = 0 ;
17651   bool result;
17652
17653   arg1 = (Dali::Property::Value *)jarg1;
17654   arg2 = (Dali::Vector4 *)jarg2;
17655   if (!arg2) {
17656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17657     return 0;
17658   }
17659   {
17660     try {
17661       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17662     } catch (std::out_of_range& e) {
17663       {
17664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17665       };
17666     } catch (std::exception& e) {
17667       {
17668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17669       };
17670     } catch (Dali::DaliException e) {
17671       {
17672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17673       };
17674     } catch (...) {
17675       {
17676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17677       };
17678     }
17679   }
17680
17681   jresult = result;
17682   return jresult;
17683 }
17684
17685
17686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17687   unsigned int jresult ;
17688   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17689   Dali::Matrix3 *arg2 = 0 ;
17690   bool result;
17691
17692   arg1 = (Dali::Property::Value *)jarg1;
17693   arg2 = (Dali::Matrix3 *)jarg2;
17694   if (!arg2) {
17695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17696     return 0;
17697   }
17698   {
17699     try {
17700       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17701     } catch (std::out_of_range& e) {
17702       {
17703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17704       };
17705     } catch (std::exception& e) {
17706       {
17707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17708       };
17709     } catch (Dali::DaliException e) {
17710       {
17711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17712       };
17713     } catch (...) {
17714       {
17715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17716       };
17717     }
17718   }
17719
17720   jresult = result;
17721   return jresult;
17722 }
17723
17724
17725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17726   unsigned int jresult ;
17727   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17728   Dali::Matrix *arg2 = 0 ;
17729   bool result;
17730
17731   arg1 = (Dali::Property::Value *)jarg1;
17732   arg2 = (Dali::Matrix *)jarg2;
17733   if (!arg2) {
17734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17735     return 0;
17736   }
17737   {
17738     try {
17739       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17740     } catch (std::out_of_range& e) {
17741       {
17742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17743       };
17744     } catch (std::exception& e) {
17745       {
17746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17747       };
17748     } catch (Dali::DaliException e) {
17749       {
17750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17751       };
17752     } catch (...) {
17753       {
17754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17755       };
17756     }
17757   }
17758
17759   jresult = result;
17760   return jresult;
17761 }
17762
17763
17764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17765   unsigned int jresult ;
17766   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17767   Dali::AngleAxis *arg2 = 0 ;
17768   bool result;
17769
17770   arg1 = (Dali::Property::Value *)jarg1;
17771   arg2 = (Dali::AngleAxis *)jarg2;
17772   if (!arg2) {
17773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17774     return 0;
17775   }
17776   {
17777     try {
17778       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17779     } catch (std::out_of_range& e) {
17780       {
17781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17782       };
17783     } catch (std::exception& e) {
17784       {
17785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17786       };
17787     } catch (Dali::DaliException e) {
17788       {
17789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17790       };
17791     } catch (...) {
17792       {
17793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17794       };
17795     }
17796   }
17797
17798   jresult = result;
17799   return jresult;
17800 }
17801
17802
17803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17804   unsigned int jresult ;
17805   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17806   Dali::Quaternion *arg2 = 0 ;
17807   bool result;
17808
17809   arg1 = (Dali::Property::Value *)jarg1;
17810   arg2 = (Dali::Quaternion *)jarg2;
17811   if (!arg2) {
17812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17813     return 0;
17814   }
17815   {
17816     try {
17817       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17818     } catch (std::out_of_range& e) {
17819       {
17820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17821       };
17822     } catch (std::exception& e) {
17823       {
17824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17825       };
17826     } catch (Dali::DaliException e) {
17827       {
17828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17829       };
17830     } catch (...) {
17831       {
17832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17833       };
17834     }
17835   }
17836
17837   jresult = result;
17838   return jresult;
17839 }
17840
17841
17842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17843   unsigned int jresult ;
17844   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17845   std::string *arg2 = 0 ;
17846   bool result;
17847
17848   arg1 = (Dali::Property::Value *)jarg1;
17849
17850   //typemap in
17851   std::string temp;
17852   arg2 = &temp;
17853
17854   {
17855     try {
17856       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17857     } catch (std::out_of_range& e) {
17858       {
17859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17860       };
17861     } catch (std::exception& e) {
17862       {
17863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17864       };
17865     } catch (Dali::DaliException e) {
17866       {
17867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17868       };
17869     } catch (...) {
17870       {
17871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17872       };
17873     }
17874   }
17875
17876   jresult = result;
17877
17878   //Typemap argout in c++ file.
17879   //This will convert c++ string to c# string
17880   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17881
17882   return jresult;
17883 }
17884
17885
17886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17887   unsigned int jresult ;
17888   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17889   Dali::Property::Array *arg2 = 0 ;
17890   bool result;
17891
17892   arg1 = (Dali::Property::Value *)jarg1;
17893   arg2 = (Dali::Property::Array *)jarg2;
17894   if (!arg2) {
17895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17896     return 0;
17897   }
17898   {
17899     try {
17900       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17901     } catch (std::out_of_range& e) {
17902       {
17903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17904       };
17905     } catch (std::exception& e) {
17906       {
17907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17908       };
17909     } catch (Dali::DaliException e) {
17910       {
17911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17912       };
17913     } catch (...) {
17914       {
17915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17916       };
17917     }
17918   }
17919
17920   jresult = result;
17921   return jresult;
17922 }
17923
17924
17925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17926   unsigned int jresult ;
17927   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17928   Dali::Property::Map *arg2 = 0 ;
17929   bool result;
17930
17931   arg1 = (Dali::Property::Value *)jarg1;
17932   arg2 = (Dali::Property::Map *)jarg2;
17933   if (!arg2) {
17934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17935     return 0;
17936   }
17937   {
17938     try {
17939       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17940     } catch (std::out_of_range& e) {
17941       {
17942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17943       };
17944     } catch (std::exception& e) {
17945       {
17946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17947       };
17948     } catch (Dali::DaliException e) {
17949       {
17950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17951       };
17952     } catch (...) {
17953       {
17954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17955       };
17956     }
17957   }
17958
17959   jresult = result;
17960   return jresult;
17961 }
17962
17963
17964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17965   unsigned int jresult ;
17966   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17967   Extents *arg2 = 0 ;
17968   bool result;
17969
17970   arg1 = (Dali::Property::Value *)jarg1;
17971   arg2 = (Extents *)jarg2;
17972   if (!arg2) {
17973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17974     return 0;
17975   }
17976   {
17977     try {
17978       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17979     } catch (std::out_of_range& e) {
17980       {
17981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17982       };
17983     } catch (std::exception& e) {
17984       {
17985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17986       };
17987     } catch (...) {
17988       {
17989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17990       };
17991     }
17992   }
17993   jresult = result;
17994   return jresult;
17995 }
17996
17997
17998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17999   void * jresult ;
18000   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18001   Dali::Property::Array *result = 0 ;
18002
18003   arg1 = (Dali::Property::Value *)jarg1;
18004   {
18005     try {
18006       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
18007     } catch (std::out_of_range& e) {
18008       {
18009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18010       };
18011     } catch (std::exception& e) {
18012       {
18013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18014       };
18015     } catch (Dali::DaliException e) {
18016       {
18017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18018       };
18019     } catch (...) {
18020       {
18021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18022       };
18023     }
18024   }
18025
18026   jresult = (void *)result;
18027   return jresult;
18028 }
18029
18030
18031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
18032   void * jresult ;
18033   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18034   Dali::Property::Map *result = 0 ;
18035
18036   arg1 = (Dali::Property::Value *)jarg1;
18037   {
18038     try {
18039       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18040     } catch (std::out_of_range& e) {
18041       {
18042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18043       };
18044     } catch (std::exception& e) {
18045       {
18046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18047       };
18048     } catch (Dali::DaliException e) {
18049       {
18050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18051       };
18052     } catch (...) {
18053       {
18054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18055       };
18056     }
18057   }
18058
18059   jresult = (void *)result;
18060   return jresult;
18061 }
18062
18063
18064 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18065   char * jresult ;
18066   Dali::Property::Type arg1 ;
18067   char *result = 0 ;
18068
18069   arg1 = (Dali::Property::Type)jarg1;
18070   {
18071     try {
18072       result = (char *)Dali::PropertyTypes::GetName(arg1);
18073     } catch (std::out_of_range& e) {
18074       {
18075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18076       };
18077     } catch (std::exception& e) {
18078       {
18079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18080       };
18081     } catch (Dali::DaliException e) {
18082       {
18083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18084       };
18085     } catch (...) {
18086       {
18087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18088       };
18089     }
18090   }
18091
18092   jresult = SWIG_csharp_string_callback((const char *)result);
18093   return jresult;
18094 }
18095
18096
18097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18098   unsigned int jresult ;
18099   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18100   std::string *arg2 = 0 ;
18101   Dali::Property::Map *arg3 = 0 ;
18102   bool result;
18103
18104   arg1 = (Dali::BaseObject *)jarg1;
18105   if (!jarg2) {
18106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18107     return 0;
18108   }
18109   std::string arg2_str(jarg2);
18110   arg2 = &arg2_str;
18111   arg3 = (Dali::Property::Map *)jarg3;
18112   if (!arg3) {
18113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18114     return 0;
18115   }
18116   {
18117     try {
18118       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18119     } catch (std::out_of_range& e) {
18120       {
18121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18122       };
18123     } catch (std::exception& e) {
18124       {
18125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18126       };
18127     } catch (Dali::DaliException e) {
18128       {
18129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18130       };
18131     } catch (...) {
18132       {
18133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18134       };
18135     }
18136   }
18137
18138   jresult = result;
18139
18140   //argout typemap for const std::string&
18141
18142   return jresult;
18143 }
18144
18145
18146 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18147   char * jresult ;
18148   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18149   std::string *result = 0 ;
18150
18151   arg1 = (Dali::BaseObject *)jarg1;
18152   {
18153     try {
18154       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18155     } catch (std::out_of_range& e) {
18156       {
18157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18158       };
18159     } catch (std::exception& e) {
18160       {
18161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18162       };
18163     } catch (Dali::DaliException e) {
18164       {
18165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18166       };
18167     } catch (...) {
18168       {
18169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18170       };
18171     }
18172   }
18173
18174   jresult = SWIG_csharp_string_callback(result->c_str());
18175   return jresult;
18176 }
18177
18178
18179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18180   unsigned int jresult ;
18181   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18182   Dali::TypeInfo *arg2 = 0 ;
18183   bool result;
18184
18185   arg1 = (Dali::BaseObject *)jarg1;
18186   arg2 = (Dali::TypeInfo *)jarg2;
18187   if (!arg2) {
18188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18189     return 0;
18190   }
18191   {
18192     try {
18193       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18194     } catch (std::out_of_range& e) {
18195       {
18196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18197       };
18198     } catch (std::exception& e) {
18199       {
18200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18201       };
18202     } catch (Dali::DaliException e) {
18203       {
18204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18205       };
18206     } catch (...) {
18207       {
18208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18209       };
18210     }
18211   }
18212
18213   jresult = result;
18214   return jresult;
18215 }
18216
18217
18218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18219   unsigned int jresult ;
18220   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18221   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18222   std::string *arg3 = 0 ;
18223   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18224   bool result;
18225
18226   arg1 = (Dali::BaseObject *)jarg1;
18227   arg2 = (ConnectionTrackerInterface *)jarg2;
18228   if (!jarg3) {
18229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18230     return 0;
18231   }
18232   std::string arg3_str(jarg3);
18233   arg3 = &arg3_str;
18234   arg4 = (FunctorDelegate *)jarg4;
18235   {
18236     try {
18237       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18238     } catch (std::out_of_range& e) {
18239       {
18240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18241       };
18242     } catch (std::exception& e) {
18243       {
18244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18245       };
18246     } catch (Dali::DaliException e) {
18247       {
18248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18249       };
18250     } catch (...) {
18251       {
18252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18253       };
18254     }
18255   }
18256
18257   jresult = result;
18258
18259   //argout typemap for const std::string&
18260
18261   return jresult;
18262 }
18263
18264
18265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18266   void * jresult ;
18267   Dali::BaseHandle *arg1 = 0 ;
18268   Dali::BaseObject *result = 0 ;
18269
18270   arg1 = (Dali::BaseHandle *)jarg1;
18271   if (!arg1) {
18272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18273     return 0;
18274   }
18275   {
18276     try {
18277       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18278     } catch (std::out_of_range& e) {
18279       {
18280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18281       };
18282     } catch (std::exception& e) {
18283       {
18284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18285       };
18286     } catch (Dali::DaliException e) {
18287       {
18288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18289       };
18290     } catch (...) {
18291       {
18292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18293       };
18294     }
18295   }
18296
18297   jresult = (void *)result;
18298   return jresult;
18299 }
18300
18301
18302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18303   void * jresult ;
18304   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18305   Dali::BaseHandle *result = 0 ;
18306
18307   arg1 = (Dali::BaseObject *)jarg1;
18308   {
18309     try {
18310       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18311     } catch (std::out_of_range& e) {
18312       {
18313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18314       };
18315     } catch (std::exception& e) {
18316       {
18317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18318       };
18319     } catch (Dali::DaliException e) {
18320       {
18321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18322       };
18323     } catch (...) {
18324       {
18325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18326       };
18327     }
18328   }
18329
18330   jresult = (void *)result;
18331   return jresult;
18332 }
18333
18334
18335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18336   void * jresult ;
18337   Dali::BaseHandle *result = 0 ;
18338
18339   {
18340     try {
18341       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18342     } catch (std::out_of_range& e) {
18343       {
18344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18345       };
18346     } catch (std::exception& e) {
18347       {
18348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18349       };
18350     } catch (Dali::DaliException e) {
18351       {
18352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18353       };
18354     } catch (...) {
18355       {
18356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18357       };
18358     }
18359   }
18360
18361   jresult = (void *)result;
18362   return jresult;
18363 }
18364
18365
18366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18367   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18368
18369   arg1 = (Dali::BaseHandle *)jarg1;
18370   {
18371     try {
18372       delete arg1;
18373     } catch (std::out_of_range& e) {
18374       {
18375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18376       };
18377     } catch (std::exception& e) {
18378       {
18379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18380       };
18381     } catch (Dali::DaliException e) {
18382       {
18383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18384       };
18385     } catch (...) {
18386       {
18387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18388       };
18389     }
18390   }
18391
18392 }
18393
18394
18395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18396   void * jresult ;
18397   Dali::BaseHandle *arg1 = 0 ;
18398   Dali::BaseHandle *result = 0 ;
18399
18400   arg1 = (Dali::BaseHandle *)jarg1;
18401   if (!arg1) {
18402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18403     return 0;
18404   }
18405   {
18406     try {
18407       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18408     } catch (std::out_of_range& e) {
18409       {
18410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18411       };
18412     } catch (std::exception& e) {
18413       {
18414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18415       };
18416     } catch (Dali::DaliException e) {
18417       {
18418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18419       };
18420     } catch (...) {
18421       {
18422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18423       };
18424     }
18425   }
18426
18427   jresult = (void *)result;
18428   return jresult;
18429 }
18430
18431
18432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18433   void * jresult ;
18434   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18435   Dali::BaseHandle *arg2 = 0 ;
18436   Dali::BaseHandle *result = 0 ;
18437
18438   arg1 = (Dali::BaseHandle *)jarg1;
18439   arg2 = (Dali::BaseHandle *)jarg2;
18440   if (!arg2) {
18441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18442     return 0;
18443   }
18444   {
18445     try {
18446       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18447     } catch (std::out_of_range& e) {
18448       {
18449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18450       };
18451     } catch (std::exception& e) {
18452       {
18453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18454       };
18455     } catch (Dali::DaliException e) {
18456       {
18457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18458       };
18459     } catch (...) {
18460       {
18461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18462       };
18463     }
18464   }
18465
18466   jresult = (void *)result;
18467   return jresult;
18468 }
18469
18470
18471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18472   unsigned int jresult ;
18473   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18474   std::string *arg2 = 0 ;
18475   Dali::Property::Map *arg3 = 0 ;
18476   bool result;
18477
18478   arg1 = (Dali::BaseHandle *)jarg1;
18479   if (!jarg2) {
18480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18481     return 0;
18482   }
18483   std::string arg2_str(jarg2);
18484   arg2 = &arg2_str;
18485   arg3 = (Dali::Property::Map *)jarg3;
18486   if (!arg3) {
18487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18488     return 0;
18489   }
18490   {
18491     try {
18492       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18493     } catch (std::out_of_range& e) {
18494       {
18495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18496       };
18497     } catch (std::exception& e) {
18498       {
18499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18500       };
18501     } catch (Dali::DaliException e) {
18502       {
18503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18504       };
18505     } catch (...) {
18506       {
18507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18508       };
18509     }
18510   }
18511
18512   jresult = result;
18513
18514   //argout typemap for const std::string&
18515
18516   return jresult;
18517 }
18518
18519
18520 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18521   char * jresult ;
18522   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18523   std::string *result = 0 ;
18524
18525   arg1 = (Dali::BaseHandle *)jarg1;
18526   {
18527     try {
18528       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18529     } catch (std::out_of_range& e) {
18530       {
18531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18532       };
18533     } catch (std::exception& e) {
18534       {
18535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18536       };
18537     } catch (Dali::DaliException e) {
18538       {
18539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18540       };
18541     } catch (...) {
18542       {
18543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18544       };
18545     }
18546   }
18547
18548   jresult = SWIG_csharp_string_callback(result->c_str());
18549   return jresult;
18550 }
18551
18552
18553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18554   unsigned int jresult ;
18555   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18556   Dali::TypeInfo *arg2 = 0 ;
18557   bool result;
18558
18559   arg1 = (Dali::BaseHandle *)jarg1;
18560   arg2 = (Dali::TypeInfo *)jarg2;
18561   if (!arg2) {
18562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18563     return 0;
18564   }
18565   {
18566     try {
18567       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18568     } catch (std::out_of_range& e) {
18569       {
18570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18571       };
18572     } catch (std::exception& e) {
18573       {
18574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18575       };
18576     } catch (Dali::DaliException e) {
18577       {
18578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18579       };
18580     } catch (...) {
18581       {
18582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18583       };
18584     }
18585   }
18586
18587   jresult = result;
18588   return jresult;
18589 }
18590
18591
18592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18593   void * jresult ;
18594   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18595   Dali::BaseObject *result = 0 ;
18596
18597   arg1 = (Dali::BaseHandle *)jarg1;
18598   {
18599     try {
18600       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18601     } catch (std::out_of_range& e) {
18602       {
18603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18604       };
18605     } catch (std::exception& e) {
18606       {
18607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18608       };
18609     } catch (Dali::DaliException e) {
18610       {
18611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18612       };
18613     } catch (...) {
18614       {
18615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18616       };
18617     }
18618   }
18619
18620   jresult = (void *)result;
18621   return jresult;
18622 }
18623
18624
18625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18626   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18627
18628   arg1 = (Dali::BaseHandle *)jarg1;
18629   {
18630     try {
18631       (arg1)->Reset();
18632     } catch (std::out_of_range& e) {
18633       {
18634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18635       };
18636     } catch (std::exception& e) {
18637       {
18638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18639       };
18640     } catch (Dali::DaliException e) {
18641       {
18642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18643       };
18644     } catch (...) {
18645       {
18646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18647       };
18648     }
18649   }
18650
18651 }
18652
18653
18654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18655   unsigned int jresult ;
18656   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18657   Dali::BaseHandle *arg2 = 0 ;
18658   bool result;
18659
18660   arg1 = (Dali::BaseHandle *)jarg1;
18661   arg2 = (Dali::BaseHandle *)jarg2;
18662   if (!arg2) {
18663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18664     return 0;
18665   }
18666   {
18667     try {
18668       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18669     } catch (std::out_of_range& e) {
18670       {
18671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18672       };
18673     } catch (std::exception& e) {
18674       {
18675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18676       };
18677     } catch (Dali::DaliException e) {
18678       {
18679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18680       };
18681     } catch (...) {
18682       {
18683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18684       };
18685     }
18686   }
18687
18688   jresult = result;
18689   return jresult;
18690 }
18691
18692
18693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18694   unsigned int jresult ;
18695   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18696   Dali::BaseHandle *arg2 = 0 ;
18697   bool result;
18698
18699   arg1 = (Dali::BaseHandle *)jarg1;
18700   arg2 = (Dali::BaseHandle *)jarg2;
18701   if (!arg2) {
18702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18703     return 0;
18704   }
18705   {
18706     try {
18707       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18708     } catch (std::out_of_range& e) {
18709       {
18710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18711       };
18712     } catch (std::exception& e) {
18713       {
18714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18715       };
18716     } catch (Dali::DaliException e) {
18717       {
18718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18719       };
18720     } catch (...) {
18721       {
18722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18723       };
18724     }
18725   }
18726
18727   jresult = result;
18728   return jresult;
18729 }
18730
18731
18732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18733   void * jresult ;
18734   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18735   Dali::RefObject *result = 0 ;
18736
18737   arg1 = (Dali::BaseHandle *)jarg1;
18738   {
18739     try {
18740       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18741     } catch (std::out_of_range& e) {
18742       {
18743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18744       };
18745     } catch (std::exception& e) {
18746       {
18747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18748       };
18749     } catch (Dali::DaliException e) {
18750       {
18751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18752       };
18753     } catch (...) {
18754       {
18755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18756       };
18757     }
18758   }
18759
18760   jresult = (void *)result;
18761   return jresult;
18762 }
18763
18764
18765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18766   unsigned int jresult ;
18767   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18768   bool result;
18769
18770   arg1 = (Dali::BaseHandle *)jarg1;
18771   {
18772     try {
18773       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18774     } catch (std::out_of_range& e) {
18775       {
18776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18777       };
18778     } catch (std::exception& e) {
18779       {
18780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18781       };
18782     } catch (Dali::DaliException e) {
18783       {
18784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18785       };
18786     } catch (...) {
18787       {
18788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18789       };
18790     }
18791   }
18792
18793   jresult = result;
18794   return jresult;
18795 }
18796
18797
18798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18799   unsigned int jresult ;
18800   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18801   Dali::BaseHandle *arg2 = 0 ;
18802   bool result;
18803
18804   arg1 = (Dali::BaseHandle *)jarg1;
18805   arg2 = (Dali::BaseHandle *)jarg2;
18806   if (!arg2) {
18807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18808     return 0;
18809   }
18810   {
18811     try {
18812       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18813     } catch (std::out_of_range& e) {
18814       {
18815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18816       };
18817     } catch (std::exception& e) {
18818       {
18819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18820       };
18821     } catch (Dali::DaliException e) {
18822       {
18823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18824       };
18825     } catch (...) {
18826       {
18827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18828       };
18829     }
18830   }
18831
18832   jresult = result;
18833   return jresult;
18834 }
18835
18836
18837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18838   unsigned int jresult ;
18839   Dali::BaseHandle *arg1 = 0 ;
18840   Dali::BaseHandle *arg2 = 0 ;
18841   bool result;
18842
18843   arg1 = (Dali::BaseHandle *)jarg1;
18844   if (!arg1) {
18845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18846     return 0;
18847   }
18848   arg2 = (Dali::BaseHandle *)jarg2;
18849   if (!arg2) {
18850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18851     return 0;
18852   }
18853   {
18854     try {
18855       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18856     } catch (std::out_of_range& e) {
18857       {
18858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18859       };
18860     } catch (std::exception& e) {
18861       {
18862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18863       };
18864     } catch (Dali::DaliException e) {
18865       {
18866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18867       };
18868     } catch (...) {
18869       {
18870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18871       };
18872     }
18873   }
18874
18875   jresult = result;
18876   return jresult;
18877 }
18878
18879
18880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18881   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18882
18883   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18884   {
18885     try {
18886       delete arg1;
18887     } catch (std::out_of_range& e) {
18888       {
18889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18890       };
18891     } catch (std::exception& e) {
18892       {
18893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18894       };
18895     } catch (Dali::DaliException e) {
18896       {
18897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18898       };
18899     } catch (...) {
18900       {
18901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18902       };
18903     }
18904   }
18905
18906 }
18907
18908
18909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18910   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18911   SlotObserver *arg2 = (SlotObserver *) 0 ;
18912   CallbackBase *arg3 = (CallbackBase *) 0 ;
18913
18914   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18915   arg2 = (SlotObserver *)jarg2;
18916   arg3 = (CallbackBase *)jarg3;
18917   {
18918     try {
18919       (arg1)->SignalConnected(arg2,arg3);
18920     } catch (std::out_of_range& e) {
18921       {
18922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18923       };
18924     } catch (std::exception& e) {
18925       {
18926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18927       };
18928     } catch (Dali::DaliException e) {
18929       {
18930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18931       };
18932     } catch (...) {
18933       {
18934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18935       };
18936     }
18937   }
18938
18939 }
18940
18941
18942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18943   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18944
18945   arg1 = (Dali::SignalObserver *)jarg1;
18946   {
18947     try {
18948       delete arg1;
18949     } catch (std::out_of_range& e) {
18950       {
18951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18952       };
18953     } catch (std::exception& e) {
18954       {
18955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18956       };
18957     } catch (Dali::DaliException e) {
18958       {
18959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18960       };
18961     } catch (...) {
18962       {
18963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18964       };
18965     }
18966   }
18967
18968 }
18969
18970
18971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18972   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18973   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18974   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18975
18976   arg1 = (Dali::SignalObserver *)jarg1;
18977   arg2 = (Dali::SlotObserver *)jarg2;
18978   arg3 = (Dali::CallbackBase *)jarg3;
18979   {
18980     try {
18981       (arg1)->SignalDisconnected(arg2,arg3);
18982     } catch (std::out_of_range& e) {
18983       {
18984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18985       };
18986     } catch (std::exception& e) {
18987       {
18988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18989       };
18990     } catch (Dali::DaliException e) {
18991       {
18992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18993       };
18994     } catch (...) {
18995       {
18996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18997       };
18998     }
18999   }
19000
19001 }
19002
19003
19004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
19005   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19006
19007   arg1 = (Dali::SlotObserver *)jarg1;
19008   {
19009     try {
19010       delete arg1;
19011     } catch (std::out_of_range& e) {
19012       {
19013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19014       };
19015     } catch (std::exception& e) {
19016       {
19017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19018       };
19019     } catch (Dali::DaliException e) {
19020       {
19021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19022       };
19023     } catch (...) {
19024       {
19025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19026       };
19027     }
19028   }
19029
19030 }
19031
19032
19033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19034   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19035   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19036
19037   arg1 = (Dali::SlotObserver *)jarg1;
19038   arg2 = (Dali::CallbackBase *)jarg2;
19039   {
19040     try {
19041       (arg1)->SlotDisconnected(arg2);
19042     } catch (std::out_of_range& e) {
19043       {
19044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19045       };
19046     } catch (std::exception& e) {
19047       {
19048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19049       };
19050     } catch (Dali::DaliException e) {
19051       {
19052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19053       };
19054     } catch (...) {
19055       {
19056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19057       };
19058     }
19059   }
19060
19061 }
19062
19063
19064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19065   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19066
19067   arg1 = (Dali::ConnectionTracker *)jarg1;
19068   {
19069     try {
19070       delete arg1;
19071     } catch (std::out_of_range& e) {
19072       {
19073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19074       };
19075     } catch (std::exception& e) {
19076       {
19077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19078       };
19079     } catch (Dali::DaliException e) {
19080       {
19081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19082       };
19083     } catch (...) {
19084       {
19085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19086       };
19087     }
19088   }
19089
19090 }
19091
19092
19093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19094   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19095
19096   arg1 = (Dali::ConnectionTracker *)jarg1;
19097   {
19098     try {
19099       (arg1)->DisconnectAll();
19100     } catch (std::out_of_range& e) {
19101       {
19102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19103       };
19104     } catch (std::exception& e) {
19105       {
19106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19107       };
19108     } catch (Dali::DaliException e) {
19109       {
19110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19111       };
19112     } catch (...) {
19113       {
19114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19115       };
19116     }
19117   }
19118
19119 }
19120
19121
19122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19123   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19124   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19125   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19126
19127   arg1 = (Dali::ConnectionTracker *)jarg1;
19128   arg2 = (Dali::SlotObserver *)jarg2;
19129   arg3 = (Dali::CallbackBase *)jarg3;
19130   {
19131     try {
19132       (arg1)->SignalConnected(arg2,arg3);
19133     } catch (std::out_of_range& e) {
19134       {
19135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19136       };
19137     } catch (std::exception& e) {
19138       {
19139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19140       };
19141     } catch (Dali::DaliException e) {
19142       {
19143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19144       };
19145     } catch (...) {
19146       {
19147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19148       };
19149     }
19150   }
19151
19152 }
19153
19154
19155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19156   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19157   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19158   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19159
19160   arg1 = (Dali::ConnectionTracker *)jarg1;
19161   arg2 = (Dali::SlotObserver *)jarg2;
19162   arg3 = (Dali::CallbackBase *)jarg3;
19163   {
19164     try {
19165       (arg1)->SignalDisconnected(arg2,arg3);
19166     } catch (std::out_of_range& e) {
19167       {
19168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19169       };
19170     } catch (std::exception& e) {
19171       {
19172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19173       };
19174     } catch (Dali::DaliException e) {
19175       {
19176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19177       };
19178     } catch (...) {
19179       {
19180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19181       };
19182     }
19183   }
19184
19185 }
19186
19187
19188 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19189   unsigned long jresult ;
19190   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19191   std::size_t result;
19192
19193   arg1 = (Dali::ConnectionTracker *)jarg1;
19194   {
19195     try {
19196       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19197     } catch (std::out_of_range& e) {
19198       {
19199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19200       };
19201     } catch (std::exception& e) {
19202       {
19203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19204       };
19205     } catch (Dali::DaliException e) {
19206       {
19207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19208       };
19209     } catch (...) {
19210       {
19211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19212       };
19213     }
19214   }
19215
19216   jresult = (unsigned long)result;
19217   return jresult;
19218 }
19219
19220
19221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19222   void * jresult ;
19223   Dali::ObjectRegistry *result = 0 ;
19224
19225   {
19226     try {
19227       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19228     } catch (std::out_of_range& e) {
19229       {
19230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19231       };
19232     } catch (std::exception& e) {
19233       {
19234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19235       };
19236     } catch (Dali::DaliException e) {
19237       {
19238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19239       };
19240     } catch (...) {
19241       {
19242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19243       };
19244     }
19245   }
19246
19247   jresult = (void *)result;
19248   return jresult;
19249 }
19250
19251
19252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19253   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19254
19255   arg1 = (Dali::ObjectRegistry *)jarg1;
19256   {
19257     try {
19258       delete arg1;
19259     } catch (std::out_of_range& e) {
19260       {
19261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19262       };
19263     } catch (std::exception& e) {
19264       {
19265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19266       };
19267     } catch (Dali::DaliException e) {
19268       {
19269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19270       };
19271     } catch (...) {
19272       {
19273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19274       };
19275     }
19276   }
19277
19278 }
19279
19280
19281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19282   void * jresult ;
19283   Dali::ObjectRegistry *arg1 = 0 ;
19284   Dali::ObjectRegistry *result = 0 ;
19285
19286   arg1 = (Dali::ObjectRegistry *)jarg1;
19287   if (!arg1) {
19288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19289     return 0;
19290   }
19291   {
19292     try {
19293       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19294     } catch (std::out_of_range& e) {
19295       {
19296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19297       };
19298     } catch (std::exception& e) {
19299       {
19300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19301       };
19302     } catch (Dali::DaliException e) {
19303       {
19304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19305       };
19306     } catch (...) {
19307       {
19308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19309       };
19310     }
19311   }
19312
19313   jresult = (void *)result;
19314   return jresult;
19315 }
19316
19317
19318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19319   void * jresult ;
19320   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19321   Dali::ObjectRegistry *arg2 = 0 ;
19322   Dali::ObjectRegistry *result = 0 ;
19323
19324   arg1 = (Dali::ObjectRegistry *)jarg1;
19325   arg2 = (Dali::ObjectRegistry *)jarg2;
19326   if (!arg2) {
19327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19328     return 0;
19329   }
19330   {
19331     try {
19332       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19333     } catch (std::out_of_range& e) {
19334       {
19335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19336       };
19337     } catch (std::exception& e) {
19338       {
19339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19340       };
19341     } catch (Dali::DaliException e) {
19342       {
19343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19344       };
19345     } catch (...) {
19346       {
19347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19348       };
19349     }
19350   }
19351
19352   jresult = (void *)result;
19353   return jresult;
19354 }
19355
19356
19357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19358   void * jresult ;
19359   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19360   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19361
19362   arg1 = (Dali::ObjectRegistry *)jarg1;
19363   {
19364     try {
19365       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19366     } catch (std::out_of_range& e) {
19367       {
19368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19369       };
19370     } catch (std::exception& e) {
19371       {
19372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19373       };
19374     } catch (Dali::DaliException e) {
19375       {
19376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19377       };
19378     } catch (...) {
19379       {
19380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19381       };
19382     }
19383   }
19384
19385   jresult = (void *)result;
19386   return jresult;
19387 }
19388
19389
19390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19391   void * jresult ;
19392   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19393   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19394
19395   arg1 = (Dali::ObjectRegistry *)jarg1;
19396   {
19397     try {
19398       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19399     } catch (std::out_of_range& e) {
19400       {
19401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19402       };
19403     } catch (std::exception& e) {
19404       {
19405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19406       };
19407     } catch (Dali::DaliException e) {
19408       {
19409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19410       };
19411     } catch (...) {
19412       {
19413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19414       };
19415     }
19416   }
19417
19418   jresult = (void *)result;
19419   return jresult;
19420 }
19421
19422
19423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19424   void * jresult ;
19425   Dali::PropertyCondition *result = 0 ;
19426
19427   {
19428     try {
19429       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19430     } catch (std::out_of_range& e) {
19431       {
19432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19433       };
19434     } catch (std::exception& e) {
19435       {
19436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19437       };
19438     } catch (Dali::DaliException e) {
19439       {
19440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19441       };
19442     } catch (...) {
19443       {
19444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19445       };
19446     }
19447   }
19448
19449   jresult = (void *)result;
19450   return jresult;
19451 }
19452
19453
19454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19455   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19456
19457   arg1 = (Dali::PropertyCondition *)jarg1;
19458   {
19459     try {
19460       delete arg1;
19461     } catch (std::out_of_range& e) {
19462       {
19463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19464       };
19465     } catch (std::exception& e) {
19466       {
19467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19468       };
19469     } catch (Dali::DaliException e) {
19470       {
19471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19472       };
19473     } catch (...) {
19474       {
19475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19476       };
19477     }
19478   }
19479
19480 }
19481
19482
19483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19484   void * jresult ;
19485   Dali::PropertyCondition *arg1 = 0 ;
19486   Dali::PropertyCondition *result = 0 ;
19487
19488   arg1 = (Dali::PropertyCondition *)jarg1;
19489   if (!arg1) {
19490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19491     return 0;
19492   }
19493   {
19494     try {
19495       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19496     } catch (std::out_of_range& e) {
19497       {
19498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19499       };
19500     } catch (std::exception& e) {
19501       {
19502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19503       };
19504     } catch (Dali::DaliException e) {
19505       {
19506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19507       };
19508     } catch (...) {
19509       {
19510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19511       };
19512     }
19513   }
19514
19515   jresult = (void *)result;
19516   return jresult;
19517 }
19518
19519
19520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19521   void * jresult ;
19522   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19523   Dali::PropertyCondition *arg2 = 0 ;
19524   Dali::PropertyCondition *result = 0 ;
19525
19526   arg1 = (Dali::PropertyCondition *)jarg1;
19527   arg2 = (Dali::PropertyCondition *)jarg2;
19528   if (!arg2) {
19529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19530     return 0;
19531   }
19532   {
19533     try {
19534       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19535     } catch (std::out_of_range& e) {
19536       {
19537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19538       };
19539     } catch (std::exception& e) {
19540       {
19541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19542       };
19543     } catch (Dali::DaliException e) {
19544       {
19545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19546       };
19547     } catch (...) {
19548       {
19549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19550       };
19551     }
19552   }
19553
19554   jresult = (void *)result;
19555   return jresult;
19556 }
19557
19558
19559 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19560   unsigned long jresult ;
19561   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19562   std::size_t result;
19563
19564   arg1 = (Dali::PropertyCondition *)jarg1;
19565   {
19566     try {
19567       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19568     } catch (std::out_of_range& e) {
19569       {
19570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19571       };
19572     } catch (std::exception& e) {
19573       {
19574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19575       };
19576     } catch (...) {
19577       {
19578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19579       };
19580     }
19581   }
19582   jresult = (unsigned long)result;
19583   return jresult;
19584 }
19585
19586
19587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19588   float jresult ;
19589   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19590   std::size_t arg2 ;
19591   float result;
19592
19593   arg1 = (Dali::PropertyCondition *)jarg1;
19594   arg2 = (std::size_t)jarg2;
19595   {
19596     try {
19597       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19598     } catch (std::out_of_range& e) {
19599       {
19600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19601       };
19602     } catch (std::exception& e) {
19603       {
19604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19605       };
19606     } catch (...) {
19607       {
19608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19609       };
19610     }
19611   }
19612   jresult = result;
19613   return jresult;
19614 }
19615
19616
19617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19618   void * jresult ;
19619   float arg1 ;
19620   Dali::PropertyCondition result;
19621
19622   arg1 = (float)jarg1;
19623   {
19624     try {
19625       result = Dali::LessThanCondition(arg1);
19626     } catch (std::out_of_range& e) {
19627       {
19628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19629       };
19630     } catch (std::exception& e) {
19631       {
19632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19633       };
19634     } catch (Dali::DaliException e) {
19635       {
19636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19637       };
19638     } catch (...) {
19639       {
19640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19641       };
19642     }
19643   }
19644
19645   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19646   return jresult;
19647 }
19648
19649
19650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19651   void * jresult ;
19652   float arg1 ;
19653   Dali::PropertyCondition result;
19654
19655   arg1 = (float)jarg1;
19656   {
19657     try {
19658       result = Dali::GreaterThanCondition(arg1);
19659     } catch (std::out_of_range& e) {
19660       {
19661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19662       };
19663     } catch (std::exception& e) {
19664       {
19665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19666       };
19667     } catch (Dali::DaliException e) {
19668       {
19669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19670       };
19671     } catch (...) {
19672       {
19673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19674       };
19675     }
19676   }
19677
19678   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19679   return jresult;
19680 }
19681
19682
19683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19684   void * jresult ;
19685   float arg1 ;
19686   float arg2 ;
19687   Dali::PropertyCondition result;
19688
19689   arg1 = (float)jarg1;
19690   arg2 = (float)jarg2;
19691   {
19692     try {
19693       result = Dali::InsideCondition(arg1,arg2);
19694     } catch (std::out_of_range& e) {
19695       {
19696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19697       };
19698     } catch (std::exception& e) {
19699       {
19700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19701       };
19702     } catch (Dali::DaliException e) {
19703       {
19704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19705       };
19706     } catch (...) {
19707       {
19708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19709       };
19710     }
19711   }
19712
19713   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19714   return jresult;
19715 }
19716
19717
19718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19719   void * jresult ;
19720   float arg1 ;
19721   float arg2 ;
19722   Dali::PropertyCondition result;
19723
19724   arg1 = (float)jarg1;
19725   arg2 = (float)jarg2;
19726   {
19727     try {
19728       result = Dali::OutsideCondition(arg1,arg2);
19729     } catch (std::out_of_range& e) {
19730       {
19731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19732       };
19733     } catch (std::exception& e) {
19734       {
19735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19736       };
19737     } catch (Dali::DaliException e) {
19738       {
19739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19740       };
19741     } catch (...) {
19742       {
19743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19744       };
19745     }
19746   }
19747
19748   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19749   return jresult;
19750 }
19751
19752
19753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19754   void * jresult ;
19755   float arg1 ;
19756   float arg2 ;
19757   Dali::PropertyCondition result;
19758
19759   arg1 = (float)jarg1;
19760   arg2 = (float)jarg2;
19761   {
19762     try {
19763       result = Dali::StepCondition(arg1,arg2);
19764     } catch (std::out_of_range& e) {
19765       {
19766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19767       };
19768     } catch (std::exception& e) {
19769       {
19770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19771       };
19772     } catch (Dali::DaliException e) {
19773       {
19774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19775       };
19776     } catch (...) {
19777       {
19778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19779       };
19780     }
19781   }
19782
19783   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19784   return jresult;
19785 }
19786
19787
19788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19789   void * jresult ;
19790   float arg1 ;
19791   Dali::PropertyCondition result;
19792
19793   arg1 = (float)jarg1;
19794   {
19795     try {
19796       result = Dali::StepCondition(arg1);
19797     } catch (std::out_of_range& e) {
19798       {
19799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19800       };
19801     } catch (std::exception& e) {
19802       {
19803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19804       };
19805     } catch (Dali::DaliException e) {
19806       {
19807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19808       };
19809     } catch (...) {
19810       {
19811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19812       };
19813     }
19814   }
19815
19816   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19817   return jresult;
19818 }
19819
19820
19821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19822   void * jresult ;
19823   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19824   Dali::PropertyCondition result;
19825
19826   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19827   if (!arg1) {
19828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19829     return 0;
19830   }
19831   {
19832     try {
19833       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19834     } catch (std::out_of_range& e) {
19835       {
19836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19837       };
19838     } catch (std::exception& e) {
19839       {
19840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19841       };
19842     } catch (Dali::DaliException e) {
19843       {
19844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19845       };
19846     } catch (...) {
19847       {
19848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19849       };
19850     }
19851   }
19852
19853   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19854   return jresult;
19855 }
19856
19857
19858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19859   void * jresult ;
19860   Dali::PropertyNotification *result = 0 ;
19861
19862   {
19863     try {
19864       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19865     } catch (std::out_of_range& e) {
19866       {
19867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19868       };
19869     } catch (std::exception& e) {
19870       {
19871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19872       };
19873     } catch (Dali::DaliException e) {
19874       {
19875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19876       };
19877     } catch (...) {
19878       {
19879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19880       };
19881     }
19882   }
19883
19884   jresult = (void *)result;
19885   return jresult;
19886 }
19887
19888
19889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19890   void * jresult ;
19891   Dali::BaseHandle arg1 ;
19892   Dali::BaseHandle *argp1 ;
19893   Dali::PropertyNotification result;
19894
19895   argp1 = (Dali::BaseHandle *)jarg1;
19896   if (!argp1) {
19897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19898     return 0;
19899   }
19900   arg1 = *argp1;
19901   {
19902     try {
19903       result = Dali::PropertyNotification::DownCast(arg1);
19904     } catch (std::out_of_range& e) {
19905       {
19906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19907       };
19908     } catch (std::exception& e) {
19909       {
19910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19911       };
19912     } catch (Dali::DaliException e) {
19913       {
19914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19915       };
19916     } catch (...) {
19917       {
19918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19919       };
19920     }
19921   }
19922
19923   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19924   return jresult;
19925 }
19926
19927
19928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19929   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19930
19931   arg1 = (Dali::PropertyNotification *)jarg1;
19932   {
19933     try {
19934       delete arg1;
19935     } catch (std::out_of_range& e) {
19936       {
19937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19938       };
19939     } catch (std::exception& e) {
19940       {
19941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19942       };
19943     } catch (Dali::DaliException e) {
19944       {
19945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19946       };
19947     } catch (...) {
19948       {
19949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19950       };
19951     }
19952   }
19953
19954 }
19955
19956
19957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19958   void * jresult ;
19959   Dali::PropertyNotification *arg1 = 0 ;
19960   Dali::PropertyNotification *result = 0 ;
19961
19962   arg1 = (Dali::PropertyNotification *)jarg1;
19963   if (!arg1) {
19964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19965     return 0;
19966   }
19967   {
19968     try {
19969       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19970     } catch (std::out_of_range& e) {
19971       {
19972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19973       };
19974     } catch (std::exception& e) {
19975       {
19976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19977       };
19978     } catch (Dali::DaliException e) {
19979       {
19980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19981       };
19982     } catch (...) {
19983       {
19984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19985       };
19986     }
19987   }
19988
19989   jresult = (void *)result;
19990   return jresult;
19991 }
19992
19993
19994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19995   void * jresult ;
19996   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19997   Dali::PropertyNotification *arg2 = 0 ;
19998   Dali::PropertyNotification *result = 0 ;
19999
20000   arg1 = (Dali::PropertyNotification *)jarg1;
20001   arg2 = (Dali::PropertyNotification *)jarg2;
20002   if (!arg2) {
20003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
20004     return 0;
20005   }
20006   {
20007     try {
20008       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
20009     } catch (std::out_of_range& e) {
20010       {
20011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20012       };
20013     } catch (std::exception& e) {
20014       {
20015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20016       };
20017     } catch (Dali::DaliException e) {
20018       {
20019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20020       };
20021     } catch (...) {
20022       {
20023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20024       };
20025     }
20026   }
20027
20028   jresult = (void *)result;
20029   return jresult;
20030 }
20031
20032
20033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20034   void * jresult ;
20035   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20036   Dali::PropertyCondition result;
20037
20038   arg1 = (Dali::PropertyNotification *)jarg1;
20039   {
20040     try {
20041       result = (arg1)->GetCondition();
20042     } catch (std::out_of_range& e) {
20043       {
20044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20045       };
20046     } catch (std::exception& e) {
20047       {
20048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20049       };
20050     } catch (Dali::DaliException e) {
20051       {
20052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20053       };
20054     } catch (...) {
20055       {
20056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20057       };
20058     }
20059   }
20060
20061   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20062   return jresult;
20063 }
20064
20065
20066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20067   void * jresult ;
20068   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20069   Dali::Handle result;
20070
20071   arg1 = (Dali::PropertyNotification *)jarg1;
20072   {
20073     try {
20074       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20075     } catch (std::out_of_range& e) {
20076       {
20077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20078       };
20079     } catch (std::exception& e) {
20080       {
20081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20082       };
20083     } catch (Dali::DaliException e) {
20084       {
20085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20086       };
20087     } catch (...) {
20088       {
20089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20090       };
20091     }
20092   }
20093
20094   jresult = new Dali::Handle((const Dali::Handle &)result);
20095   return jresult;
20096 }
20097
20098
20099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20100   int jresult ;
20101   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20102   Dali::Property::Index result;
20103
20104   arg1 = (Dali::PropertyNotification *)jarg1;
20105   {
20106     try {
20107       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20108     } catch (std::out_of_range& e) {
20109       {
20110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20111       };
20112     } catch (std::exception& e) {
20113       {
20114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20115       };
20116     } catch (Dali::DaliException e) {
20117       {
20118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20119       };
20120     } catch (...) {
20121       {
20122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20123       };
20124     }
20125   }
20126
20127   jresult = result;
20128   return jresult;
20129 }
20130
20131
20132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20133   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20134   Dali::PropertyNotification::NotifyMode arg2 ;
20135
20136   arg1 = (Dali::PropertyNotification *)jarg1;
20137   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20138   {
20139     try {
20140       (arg1)->SetNotifyMode(arg2);
20141     } catch (std::out_of_range& e) {
20142       {
20143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20144       };
20145     } catch (std::exception& e) {
20146       {
20147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20148       };
20149     } catch (Dali::DaliException e) {
20150       {
20151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20152       };
20153     } catch (...) {
20154       {
20155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20156       };
20157     }
20158   }
20159
20160 }
20161
20162
20163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20164   int jresult ;
20165   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20166   Dali::PropertyNotification::NotifyMode result;
20167
20168   arg1 = (Dali::PropertyNotification *)jarg1;
20169   {
20170     try {
20171       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20172     } catch (std::out_of_range& e) {
20173       {
20174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20175       };
20176     } catch (std::exception& e) {
20177       {
20178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20179       };
20180     } catch (Dali::DaliException e) {
20181       {
20182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20183       };
20184     } catch (...) {
20185       {
20186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20187       };
20188     }
20189   }
20190
20191   jresult = (int)result;
20192   return jresult;
20193 }
20194
20195
20196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20197   unsigned int jresult ;
20198   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20199   bool result;
20200
20201   arg1 = (Dali::PropertyNotification *)jarg1;
20202   {
20203     try {
20204       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20205     } catch (std::out_of_range& e) {
20206       {
20207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20208       };
20209     } catch (std::exception& e) {
20210       {
20211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20212       };
20213     } catch (Dali::DaliException e) {
20214       {
20215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20216       };
20217     } catch (...) {
20218       {
20219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20220       };
20221     }
20222   }
20223
20224   jresult = result;
20225   return jresult;
20226 }
20227
20228
20229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20230   void * jresult ;
20231   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20232   Dali::PropertyNotifySignalType *result = 0 ;
20233
20234   arg1 = (Dali::PropertyNotification *)jarg1;
20235   {
20236     try {
20237       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20238     } catch (std::out_of_range& e) {
20239       {
20240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20241       };
20242     } catch (std::exception& e) {
20243       {
20244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20245       };
20246     } catch (Dali::DaliException e) {
20247       {
20248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20249       };
20250     } catch (...) {
20251       {
20252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20253       };
20254     }
20255   }
20256
20257   jresult = (void *)result;
20258   return jresult;
20259 }
20260
20261
20262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20263   void * jresult ;
20264   Dali::Handle *result = 0 ;
20265
20266   {
20267     try {
20268       result = (Dali::Handle *)new Dali::Handle();
20269     } catch (std::out_of_range& e) {
20270       {
20271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20272       };
20273     } catch (std::exception& e) {
20274       {
20275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20276       };
20277     } catch (Dali::DaliException e) {
20278       {
20279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20280       };
20281     } catch (...) {
20282       {
20283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20284       };
20285     }
20286   }
20287
20288   jresult = (void *)result;
20289   return jresult;
20290 }
20291
20292
20293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20294   void * jresult ;
20295   Dali::Handle result;
20296
20297   {
20298     try {
20299       result = Dali::Handle::New();
20300     } catch (std::out_of_range& e) {
20301       {
20302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20303       };
20304     } catch (std::exception& e) {
20305       {
20306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20307       };
20308     } catch (Dali::DaliException e) {
20309       {
20310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20311       };
20312     } catch (...) {
20313       {
20314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20315       };
20316     }
20317   }
20318
20319   jresult = new Dali::Handle((const Dali::Handle &)result);
20320   return jresult;
20321 }
20322
20323
20324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20325   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20326
20327   arg1 = (Dali::Handle *)jarg1;
20328   {
20329     try {
20330       delete arg1;
20331     } catch (std::out_of_range& e) {
20332       {
20333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20334       };
20335     } catch (std::exception& e) {
20336       {
20337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20338       };
20339     } catch (Dali::DaliException e) {
20340       {
20341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20342       };
20343     } catch (...) {
20344       {
20345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20346       };
20347     }
20348   }
20349
20350 }
20351
20352
20353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20354   void * jresult ;
20355   Dali::Handle *arg1 = 0 ;
20356   Dali::Handle *result = 0 ;
20357
20358   arg1 = (Dali::Handle *)jarg1;
20359   if (!arg1) {
20360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20361     return 0;
20362   }
20363   {
20364     try {
20365       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20366     } catch (std::out_of_range& e) {
20367       {
20368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20369       };
20370     } catch (std::exception& e) {
20371       {
20372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20373       };
20374     } catch (Dali::DaliException e) {
20375       {
20376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20377       };
20378     } catch (...) {
20379       {
20380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20381       };
20382     }
20383   }
20384
20385   jresult = (void *)result;
20386   return jresult;
20387 }
20388
20389
20390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20391   void * jresult ;
20392   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20393   Dali::Handle *arg2 = 0 ;
20394   Dali::Handle *result = 0 ;
20395
20396   arg1 = (Dali::Handle *)jarg1;
20397   arg2 = (Dali::Handle *)jarg2;
20398   if (!arg2) {
20399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20400     return 0;
20401   }
20402   {
20403     try {
20404       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20405     } catch (std::out_of_range& e) {
20406       {
20407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20408       };
20409     } catch (std::exception& e) {
20410       {
20411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20412       };
20413     } catch (Dali::DaliException e) {
20414       {
20415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20416       };
20417     } catch (...) {
20418       {
20419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20420       };
20421     }
20422   }
20423
20424   jresult = (void *)result;
20425   return jresult;
20426 }
20427
20428
20429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20430   void * jresult ;
20431   Dali::BaseHandle arg1 ;
20432   Dali::BaseHandle *argp1 ;
20433   Dali::Handle result;
20434
20435   argp1 = (Dali::BaseHandle *)jarg1;
20436   if (!argp1) {
20437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20438     return 0;
20439   }
20440   arg1 = *argp1;
20441   {
20442     try {
20443       result = Dali::Handle::DownCast(arg1);
20444     } catch (std::out_of_range& e) {
20445       {
20446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20447       };
20448     } catch (std::exception& e) {
20449       {
20450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20451       };
20452     } catch (Dali::DaliException e) {
20453       {
20454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20455       };
20456     } catch (...) {
20457       {
20458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20459       };
20460     }
20461   }
20462
20463   jresult = new Dali::Handle((const Dali::Handle &)result);
20464   return jresult;
20465 }
20466
20467
20468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20469   unsigned int jresult ;
20470   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20471   Dali::Handle::Capability arg2 ;
20472   bool result;
20473
20474   arg1 = (Dali::Handle *)jarg1;
20475   arg2 = (Dali::Handle::Capability)jarg2;
20476   {
20477     try {
20478       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20479     } catch (std::out_of_range& e) {
20480       {
20481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20482       };
20483     } catch (std::exception& e) {
20484       {
20485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20486       };
20487     } catch (Dali::DaliException e) {
20488       {
20489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20490       };
20491     } catch (...) {
20492       {
20493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20494       };
20495     }
20496   }
20497
20498   jresult = result;
20499   return jresult;
20500 }
20501
20502
20503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20504   unsigned int jresult ;
20505   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20506   unsigned int result;
20507
20508   arg1 = (Dali::Handle *)jarg1;
20509   {
20510     try {
20511       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20512     } catch (std::out_of_range& e) {
20513       {
20514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20515       };
20516     } catch (std::exception& e) {
20517       {
20518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20519       };
20520     } catch (Dali::DaliException e) {
20521       {
20522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20523       };
20524     } catch (...) {
20525       {
20526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20527       };
20528     }
20529   }
20530
20531   jresult = result;
20532   return jresult;
20533 }
20534
20535
20536 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20537   char * jresult ;
20538   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20539   Dali::Property::Index arg2 ;
20540   std::string result;
20541
20542   arg1 = (Dali::Handle *)jarg1;
20543   arg2 = (Dali::Property::Index)jarg2;
20544   {
20545     try {
20546       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20547     } catch (std::out_of_range& e) {
20548       {
20549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20550       };
20551     } catch (std::exception& e) {
20552       {
20553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20554       };
20555     } catch (Dali::DaliException e) {
20556       {
20557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20558       };
20559     } catch (...) {
20560       {
20561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20562       };
20563     }
20564   }
20565
20566   jresult = SWIG_csharp_string_callback((&result)->c_str());
20567   return jresult;
20568 }
20569
20570
20571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20572   int jresult ;
20573   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20574   std::string *arg2 = 0 ;
20575   Dali::Property::Index result;
20576
20577   arg1 = (Dali::Handle *)jarg1;
20578   if (!jarg2) {
20579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20580     return 0;
20581   }
20582   std::string arg2_str(jarg2);
20583   arg2 = &arg2_str;
20584   {
20585     try {
20586       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20587     } catch (std::out_of_range& e) {
20588       {
20589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20590       };
20591     } catch (std::exception& e) {
20592       {
20593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20594       };
20595     } catch (Dali::DaliException e) {
20596       {
20597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20598       };
20599     } catch (...) {
20600       {
20601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20602       };
20603     }
20604   }
20605
20606   jresult = result;
20607
20608   //argout typemap for const std::string&
20609
20610   return jresult;
20611 }
20612
20613
20614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20615   unsigned int jresult ;
20616   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20617   Dali::Property::Index arg2 ;
20618   bool result;
20619
20620   arg1 = (Dali::Handle *)jarg1;
20621   arg2 = (Dali::Property::Index)jarg2;
20622   {
20623     try {
20624       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20625     } catch (std::out_of_range& e) {
20626       {
20627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20628       };
20629     } catch (std::exception& e) {
20630       {
20631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20632       };
20633     } catch (Dali::DaliException e) {
20634       {
20635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20636       };
20637     } catch (...) {
20638       {
20639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20640       };
20641     }
20642   }
20643
20644   jresult = result;
20645   return jresult;
20646 }
20647
20648
20649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20650   unsigned int jresult ;
20651   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20652   Dali::Property::Index arg2 ;
20653   bool result;
20654
20655   arg1 = (Dali::Handle *)jarg1;
20656   arg2 = (Dali::Property::Index)jarg2;
20657   {
20658     try {
20659       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20660     } catch (std::out_of_range& e) {
20661       {
20662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20663       };
20664     } catch (std::exception& e) {
20665       {
20666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20667       };
20668     } catch (Dali::DaliException e) {
20669       {
20670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20671       };
20672     } catch (...) {
20673       {
20674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20675       };
20676     }
20677   }
20678
20679   jresult = result;
20680   return jresult;
20681 }
20682
20683
20684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20685   unsigned int jresult ;
20686   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20687   Dali::Property::Index arg2 ;
20688   bool result;
20689
20690   arg1 = (Dali::Handle *)jarg1;
20691   arg2 = (Dali::Property::Index)jarg2;
20692   {
20693     try {
20694       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20695     } catch (std::out_of_range& e) {
20696       {
20697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20698       };
20699     } catch (std::exception& e) {
20700       {
20701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20702       };
20703     } catch (Dali::DaliException e) {
20704       {
20705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20706       };
20707     } catch (...) {
20708       {
20709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20710       };
20711     }
20712   }
20713
20714   jresult = result;
20715   return jresult;
20716 }
20717
20718
20719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20720   int jresult ;
20721   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20722   Dali::Property::Index arg2 ;
20723   Dali::Property::Type result;
20724
20725   arg1 = (Dali::Handle *)jarg1;
20726   arg2 = (Dali::Property::Index)jarg2;
20727   {
20728     try {
20729       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20730     } catch (std::out_of_range& e) {
20731       {
20732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20733       };
20734     } catch (std::exception& e) {
20735       {
20736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20737       };
20738     } catch (Dali::DaliException e) {
20739       {
20740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20741       };
20742     } catch (...) {
20743       {
20744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20745       };
20746     }
20747   }
20748
20749   jresult = (int)result;
20750   return jresult;
20751 }
20752
20753
20754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20755   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20756   Dali::Property::Index arg2 ;
20757   Dali::Property::Value *arg3 = 0 ;
20758
20759   arg1 = (Dali::Handle *)jarg1;
20760   arg2 = (Dali::Property::Index)jarg2;
20761   arg3 = (Dali::Property::Value *)jarg3;
20762   if (!arg3) {
20763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20764     return ;
20765   }
20766   {
20767     try {
20768       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20769     } catch (std::out_of_range& e) {
20770       {
20771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20772       };
20773     } catch (std::exception& e) {
20774       {
20775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20776       };
20777     } catch (Dali::DaliException e) {
20778       {
20779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20780       };
20781     } catch (...) {
20782       {
20783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20784       };
20785     }
20786   }
20787
20788 }
20789
20790
20791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20792   int jresult ;
20793   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20794   std::string *arg2 = 0 ;
20795   Dali::Property::Value *arg3 = 0 ;
20796   Dali::Property::Index result;
20797
20798   arg1 = (Dali::Handle *)jarg1;
20799   if (!jarg2) {
20800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20801     return 0;
20802   }
20803   std::string arg2_str(jarg2);
20804   arg2 = &arg2_str;
20805   arg3 = (Dali::Property::Value *)jarg3;
20806   if (!arg3) {
20807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20808     return 0;
20809   }
20810   {
20811     try {
20812       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20813     } catch (std::out_of_range& e) {
20814       {
20815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20816       };
20817     } catch (std::exception& e) {
20818       {
20819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20820       };
20821     } catch (Dali::DaliException e) {
20822       {
20823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20824       };
20825     } catch (...) {
20826       {
20827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20828       };
20829     }
20830   }
20831
20832   jresult = result;
20833
20834   //argout typemap for const std::string&
20835
20836   return jresult;
20837 }
20838
20839
20840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20841   int jresult ;
20842   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20843   std::string *arg2 = 0 ;
20844   Dali::Property::Value *arg3 = 0 ;
20845   Dali::Property::AccessMode arg4 ;
20846   Dali::Property::Index result;
20847
20848   arg1 = (Dali::Handle *)jarg1;
20849   if (!jarg2) {
20850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20851     return 0;
20852   }
20853   std::string arg2_str(jarg2);
20854   arg2 = &arg2_str;
20855   arg3 = (Dali::Property::Value *)jarg3;
20856   if (!arg3) {
20857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20858     return 0;
20859   }
20860   arg4 = (Dali::Property::AccessMode)jarg4;
20861   {
20862     try {
20863       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20864     } catch (std::out_of_range& e) {
20865       {
20866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20867       };
20868     } catch (std::exception& e) {
20869       {
20870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20871       };
20872     } catch (Dali::DaliException e) {
20873       {
20874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20875       };
20876     } catch (...) {
20877       {
20878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20879       };
20880     }
20881   }
20882
20883   jresult = result;
20884
20885   //argout typemap for const std::string&
20886
20887   return jresult;
20888 }
20889
20890
20891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20892   void * jresult ;
20893   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20894   Dali::Property::Index arg2 ;
20895   Dali::Property::Value result;
20896
20897   arg1 = (Dali::Handle *)jarg1;
20898   arg2 = (Dali::Property::Index)jarg2;
20899   {
20900     try {
20901       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20902     } catch (std::out_of_range& e) {
20903       {
20904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20905       };
20906     } catch (std::exception& e) {
20907       {
20908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20909       };
20910     } catch (Dali::DaliException e) {
20911       {
20912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20913       };
20914     } catch (...) {
20915       {
20916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20917       };
20918     }
20919   }
20920
20921   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20922   return jresult;
20923 }
20924
20925
20926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20927   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20928   Dali::Property::IndexContainer *arg2 = 0 ;
20929
20930   arg1 = (Dali::Handle *)jarg1;
20931   arg2 = (Dali::Property::IndexContainer *)jarg2;
20932   if (!arg2) {
20933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20934     return ;
20935   }
20936   {
20937     try {
20938       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20939     } catch (std::out_of_range& e) {
20940       {
20941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20942       };
20943     } catch (std::exception& e) {
20944       {
20945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20946       };
20947     } catch (Dali::DaliException e) {
20948       {
20949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20950       };
20951     } catch (...) {
20952       {
20953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20954       };
20955     }
20956   }
20957
20958 }
20959
20960
20961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20962   void * jresult ;
20963   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20964   Dali::Property::Index arg2 ;
20965   Dali::PropertyCondition *arg3 = 0 ;
20966   Dali::PropertyNotification result;
20967
20968   arg1 = (Dali::Handle *)jarg1;
20969   arg2 = (Dali::Property::Index)jarg2;
20970   arg3 = (Dali::PropertyCondition *)jarg3;
20971   if (!arg3) {
20972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20973     return 0;
20974   }
20975   {
20976     try {
20977       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20978     } catch (std::out_of_range& e) {
20979       {
20980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20981       };
20982     } catch (std::exception& e) {
20983       {
20984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20985       };
20986     } catch (Dali::DaliException e) {
20987       {
20988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20989       };
20990     } catch (...) {
20991       {
20992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20993       };
20994     }
20995   }
20996
20997   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20998   return jresult;
20999 }
21000
21001
21002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
21003   void * jresult ;
21004   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21005   Dali::Property::Index arg2 ;
21006   int arg3 ;
21007   Dali::PropertyCondition *arg4 = 0 ;
21008   Dali::PropertyNotification result;
21009
21010   arg1 = (Dali::Handle *)jarg1;
21011   arg2 = (Dali::Property::Index)jarg2;
21012   arg3 = (int)jarg3;
21013   arg4 = (Dali::PropertyCondition *)jarg4;
21014   if (!arg4) {
21015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21016     return 0;
21017   }
21018   {
21019     try {
21020       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
21021     } catch (std::out_of_range& e) {
21022       {
21023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21024       };
21025     } catch (std::exception& e) {
21026       {
21027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21028       };
21029     } catch (Dali::DaliException e) {
21030       {
21031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21032       };
21033     } catch (...) {
21034       {
21035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21036       };
21037     }
21038   }
21039
21040   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21041   return jresult;
21042 }
21043
21044
21045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21046   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21047   Dali::PropertyNotification arg2 ;
21048   Dali::PropertyNotification *argp2 ;
21049
21050   arg1 = (Dali::Handle *)jarg1;
21051   argp2 = (Dali::PropertyNotification *)jarg2;
21052   if (!argp2) {
21053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21054     return ;
21055   }
21056   arg2 = *argp2;
21057   {
21058     try {
21059       (arg1)->RemovePropertyNotification(arg2);
21060     } catch (std::out_of_range& e) {
21061       {
21062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21063       };
21064     } catch (std::exception& e) {
21065       {
21066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21067       };
21068     } catch (Dali::DaliException e) {
21069       {
21070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21071       };
21072     } catch (...) {
21073       {
21074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21075       };
21076     }
21077   }
21078
21079 }
21080
21081
21082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21083   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21084
21085   arg1 = (Dali::Handle *)jarg1;
21086   {
21087     try {
21088       (arg1)->RemovePropertyNotifications();
21089     } catch (std::out_of_range& e) {
21090       {
21091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21092       };
21093     } catch (std::exception& e) {
21094       {
21095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21096       };
21097     } catch (Dali::DaliException e) {
21098       {
21099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21100       };
21101     } catch (...) {
21102       {
21103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21104       };
21105     }
21106   }
21107
21108 }
21109
21110
21111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21112   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21113
21114   arg1 = (Dali::Handle *)jarg1;
21115   {
21116     try {
21117       (arg1)->RemoveConstraints();
21118     } catch (std::out_of_range& e) {
21119       {
21120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21121       };
21122     } catch (std::exception& e) {
21123       {
21124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21125       };
21126     } catch (Dali::DaliException e) {
21127       {
21128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21129       };
21130     } catch (...) {
21131       {
21132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21133       };
21134     }
21135   }
21136
21137 }
21138
21139
21140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21141   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21142   unsigned int arg2 ;
21143
21144   arg1 = (Dali::Handle *)jarg1;
21145   arg2 = (unsigned int)jarg2;
21146   {
21147     try {
21148       (arg1)->RemoveConstraints(arg2);
21149     } catch (std::out_of_range& e) {
21150       {
21151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21152       };
21153     } catch (std::exception& e) {
21154       {
21155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21156       };
21157     } catch (Dali::DaliException e) {
21158       {
21159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21160       };
21161     } catch (...) {
21162       {
21163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21164       };
21165     }
21166   }
21167
21168 }
21169
21170
21171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21172   int jresult ;
21173   Dali::Property::Index result;
21174
21175   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21176   jresult = result;
21177   return jresult;
21178 }
21179
21180
21181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21182   void * jresult ;
21183   Dali::Handle result;
21184
21185   {
21186     try {
21187       result = Dali::WeightObject::New();
21188     } catch (std::out_of_range& e) {
21189       {
21190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21191       };
21192     } catch (std::exception& e) {
21193       {
21194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21195       };
21196     } catch (Dali::DaliException e) {
21197       {
21198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21199       };
21200     } catch (...) {
21201       {
21202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21203       };
21204     }
21205   }
21206
21207   jresult = new Dali::Handle((const Dali::Handle &)result);
21208   return jresult;
21209 }
21210
21211
21212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21213   void * jresult ;
21214   Dali::TypeInfo *result = 0 ;
21215
21216   {
21217     try {
21218       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21219     } catch (std::out_of_range& e) {
21220       {
21221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21222       };
21223     } catch (std::exception& e) {
21224       {
21225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21226       };
21227     } catch (Dali::DaliException e) {
21228       {
21229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21230       };
21231     } catch (...) {
21232       {
21233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21234       };
21235     }
21236   }
21237
21238   jresult = (void *)result;
21239   return jresult;
21240 }
21241
21242
21243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21244   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21245
21246   arg1 = (Dali::TypeInfo *)jarg1;
21247   {
21248     try {
21249       delete arg1;
21250     } catch (std::out_of_range& e) {
21251       {
21252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21253       };
21254     } catch (std::exception& e) {
21255       {
21256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21257       };
21258     } catch (Dali::DaliException e) {
21259       {
21260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21261       };
21262     } catch (...) {
21263       {
21264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21265       };
21266     }
21267   }
21268
21269 }
21270
21271
21272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21273   void * jresult ;
21274   Dali::TypeInfo *arg1 = 0 ;
21275   Dali::TypeInfo *result = 0 ;
21276
21277   arg1 = (Dali::TypeInfo *)jarg1;
21278   if (!arg1) {
21279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21280     return 0;
21281   }
21282   {
21283     try {
21284       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21285     } catch (std::out_of_range& e) {
21286       {
21287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21288       };
21289     } catch (std::exception& e) {
21290       {
21291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21292       };
21293     } catch (Dali::DaliException e) {
21294       {
21295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21296       };
21297     } catch (...) {
21298       {
21299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21300       };
21301     }
21302   }
21303
21304   jresult = (void *)result;
21305   return jresult;
21306 }
21307
21308
21309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21310   void * jresult ;
21311   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21312   Dali::TypeInfo *arg2 = 0 ;
21313   Dali::TypeInfo *result = 0 ;
21314
21315   arg1 = (Dali::TypeInfo *)jarg1;
21316   arg2 = (Dali::TypeInfo *)jarg2;
21317   if (!arg2) {
21318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21319     return 0;
21320   }
21321   {
21322     try {
21323       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21324     } catch (std::out_of_range& e) {
21325       {
21326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21327       };
21328     } catch (std::exception& e) {
21329       {
21330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21331       };
21332     } catch (Dali::DaliException e) {
21333       {
21334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21335       };
21336     } catch (...) {
21337       {
21338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21339       };
21340     }
21341   }
21342
21343   jresult = (void *)result;
21344   return jresult;
21345 }
21346
21347
21348 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21349   char * jresult ;
21350   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21351   std::string *result = 0 ;
21352
21353   arg1 = (Dali::TypeInfo *)jarg1;
21354   {
21355     try {
21356       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21357     } catch (std::out_of_range& e) {
21358       {
21359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21360       };
21361     } catch (std::exception& e) {
21362       {
21363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21364       };
21365     } catch (Dali::DaliException e) {
21366       {
21367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21368       };
21369     } catch (...) {
21370       {
21371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21372       };
21373     }
21374   }
21375
21376   jresult = SWIG_csharp_string_callback(result->c_str());
21377   return jresult;
21378 }
21379
21380
21381 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21382   char * jresult ;
21383   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21384   std::string *result = 0 ;
21385
21386   arg1 = (Dali::TypeInfo *)jarg1;
21387   {
21388     try {
21389       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21390     } catch (std::out_of_range& e) {
21391       {
21392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21393       };
21394     } catch (std::exception& e) {
21395       {
21396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21397       };
21398     } catch (Dali::DaliException e) {
21399       {
21400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21401       };
21402     } catch (...) {
21403       {
21404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21405       };
21406     }
21407   }
21408
21409   jresult = SWIG_csharp_string_callback(result->c_str());
21410   return jresult;
21411 }
21412
21413
21414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21415   void * jresult ;
21416   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21417   Dali::BaseHandle result;
21418
21419   arg1 = (Dali::TypeInfo *)jarg1;
21420   {
21421     try {
21422       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21423     } catch (std::out_of_range& e) {
21424       {
21425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21426       };
21427     } catch (std::exception& e) {
21428       {
21429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21430       };
21431     } catch (Dali::DaliException e) {
21432       {
21433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21434       };
21435     } catch (...) {
21436       {
21437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21438       };
21439     }
21440   }
21441
21442   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21443   return jresult;
21444 }
21445
21446
21447 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21448   unsigned long jresult ;
21449   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21450   size_t result;
21451
21452   arg1 = (Dali::TypeInfo *)jarg1;
21453   {
21454     try {
21455       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21456     } catch (std::out_of_range& e) {
21457       {
21458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21459       };
21460     } catch (std::exception& e) {
21461       {
21462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21463       };
21464     } catch (Dali::DaliException e) {
21465       {
21466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21467       };
21468     } catch (...) {
21469       {
21470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21471       };
21472     }
21473   }
21474
21475   jresult = (unsigned long)result;
21476   return jresult;
21477 }
21478
21479
21480 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21481   char * jresult ;
21482   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21483   size_t arg2 ;
21484   std::string result;
21485
21486   arg1 = (Dali::TypeInfo *)jarg1;
21487   arg2 = (size_t)jarg2;
21488   {
21489     try {
21490       result = (arg1)->GetActionName(arg2);
21491     } catch (std::out_of_range& e) {
21492       {
21493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21494       };
21495     } catch (std::exception& e) {
21496       {
21497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21498       };
21499     } catch (Dali::DaliException e) {
21500       {
21501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21502       };
21503     } catch (...) {
21504       {
21505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21506       };
21507     }
21508   }
21509
21510   jresult = SWIG_csharp_string_callback((&result)->c_str());
21511   return jresult;
21512 }
21513
21514
21515 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21516   unsigned long jresult ;
21517   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21518   size_t result;
21519
21520   arg1 = (Dali::TypeInfo *)jarg1;
21521   {
21522     try {
21523       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21524     } catch (std::out_of_range& e) {
21525       {
21526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21527       };
21528     } catch (std::exception& e) {
21529       {
21530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21531       };
21532     } catch (Dali::DaliException e) {
21533       {
21534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21535       };
21536     } catch (...) {
21537       {
21538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21539       };
21540     }
21541   }
21542
21543   jresult = (unsigned long)result;
21544   return jresult;
21545 }
21546
21547
21548 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21549   char * jresult ;
21550   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21551   size_t arg2 ;
21552   std::string result;
21553
21554   arg1 = (Dali::TypeInfo *)jarg1;
21555   arg2 = (size_t)jarg2;
21556   {
21557     try {
21558       result = (arg1)->GetSignalName(arg2);
21559     } catch (std::out_of_range& e) {
21560       {
21561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21562       };
21563     } catch (std::exception& e) {
21564       {
21565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21566       };
21567     } catch (Dali::DaliException e) {
21568       {
21569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21570       };
21571     } catch (...) {
21572       {
21573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21574       };
21575     }
21576   }
21577
21578   jresult = SWIG_csharp_string_callback((&result)->c_str());
21579   return jresult;
21580 }
21581
21582
21583 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21584   unsigned long jresult ;
21585   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21586   size_t result;
21587
21588   arg1 = (Dali::TypeInfo *)jarg1;
21589   {
21590     try {
21591       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21592     } catch (std::out_of_range& e) {
21593       {
21594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21595       };
21596     } catch (std::exception& e) {
21597       {
21598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21599       };
21600     } catch (Dali::DaliException e) {
21601       {
21602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21603       };
21604     } catch (...) {
21605       {
21606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21607       };
21608     }
21609   }
21610
21611   jresult = (unsigned long)result;
21612   return jresult;
21613 }
21614
21615
21616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21617   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21618   Dali::Property::IndexContainer *arg2 = 0 ;
21619
21620   arg1 = (Dali::TypeInfo *)jarg1;
21621   arg2 = (Dali::Property::IndexContainer *)jarg2;
21622   if (!arg2) {
21623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21624     return ;
21625   }
21626   {
21627     try {
21628       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21629     } catch (std::out_of_range& e) {
21630       {
21631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21632       };
21633     } catch (std::exception& e) {
21634       {
21635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21636       };
21637     } catch (Dali::DaliException e) {
21638       {
21639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21640       };
21641     } catch (...) {
21642       {
21643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21644       };
21645     }
21646   }
21647
21648 }
21649
21650
21651 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21652   char * jresult ;
21653   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21654   Dali::Property::Index arg2 ;
21655   std::string *result = 0 ;
21656
21657   arg1 = (Dali::TypeInfo *)jarg1;
21658   arg2 = (Dali::Property::Index)jarg2;
21659   {
21660     try {
21661       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21662     } catch (std::out_of_range& e) {
21663       {
21664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21665       };
21666     } catch (std::exception& e) {
21667       {
21668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21669       };
21670     } catch (Dali::DaliException e) {
21671       {
21672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21673       };
21674     } catch (...) {
21675       {
21676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21677       };
21678     }
21679   }
21680
21681   jresult = SWIG_csharp_string_callback(result->c_str());
21682   return jresult;
21683 }
21684
21685
21686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21687   void * jresult ;
21688   Dali::TypeRegistry result;
21689
21690   {
21691     try {
21692       result = Dali::TypeRegistry::Get();
21693     } catch (std::out_of_range& e) {
21694       {
21695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21696       };
21697     } catch (std::exception& e) {
21698       {
21699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21700       };
21701     } catch (Dali::DaliException e) {
21702       {
21703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21704       };
21705     } catch (...) {
21706       {
21707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21708       };
21709     }
21710   }
21711
21712   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21713   return jresult;
21714 }
21715
21716
21717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21718   void * jresult ;
21719   Dali::TypeRegistry *result = 0 ;
21720
21721   {
21722     try {
21723       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21724     } catch (std::out_of_range& e) {
21725       {
21726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21727       };
21728     } catch (std::exception& e) {
21729       {
21730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21731       };
21732     } catch (Dali::DaliException e) {
21733       {
21734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21735       };
21736     } catch (...) {
21737       {
21738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21739       };
21740     }
21741   }
21742
21743   jresult = (void *)result;
21744   return jresult;
21745 }
21746
21747
21748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21749   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21750
21751   arg1 = (Dali::TypeRegistry *)jarg1;
21752   {
21753     try {
21754       delete arg1;
21755     } catch (std::out_of_range& e) {
21756       {
21757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21758       };
21759     } catch (std::exception& e) {
21760       {
21761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21762       };
21763     } catch (Dali::DaliException e) {
21764       {
21765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21766       };
21767     } catch (...) {
21768       {
21769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21770       };
21771     }
21772   }
21773
21774 }
21775
21776
21777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21778   void * jresult ;
21779   Dali::TypeRegistry *arg1 = 0 ;
21780   Dali::TypeRegistry *result = 0 ;
21781
21782   arg1 = (Dali::TypeRegistry *)jarg1;
21783   if (!arg1) {
21784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21785     return 0;
21786   }
21787   {
21788     try {
21789       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21790     } catch (std::out_of_range& e) {
21791       {
21792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21793       };
21794     } catch (std::exception& e) {
21795       {
21796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21797       };
21798     } catch (Dali::DaliException e) {
21799       {
21800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21801       };
21802     } catch (...) {
21803       {
21804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21805       };
21806     }
21807   }
21808
21809   jresult = (void *)result;
21810   return jresult;
21811 }
21812
21813
21814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21815   void * jresult ;
21816   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21817   Dali::TypeRegistry *arg2 = 0 ;
21818   Dali::TypeRegistry *result = 0 ;
21819
21820   arg1 = (Dali::TypeRegistry *)jarg1;
21821   arg2 = (Dali::TypeRegistry *)jarg2;
21822   if (!arg2) {
21823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21824     return 0;
21825   }
21826   {
21827     try {
21828       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21829     } catch (std::out_of_range& e) {
21830       {
21831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21832       };
21833     } catch (std::exception& e) {
21834       {
21835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21836       };
21837     } catch (Dali::DaliException e) {
21838       {
21839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21840       };
21841     } catch (...) {
21842       {
21843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21844       };
21845     }
21846   }
21847
21848   jresult = (void *)result;
21849   return jresult;
21850 }
21851
21852
21853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21854   void * jresult ;
21855   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21856   std::string *arg2 = 0 ;
21857   Dali::TypeInfo result;
21858
21859   arg1 = (Dali::TypeRegistry *)jarg1;
21860   if (!jarg2) {
21861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21862     return 0;
21863   }
21864   std::string arg2_str(jarg2);
21865   arg2 = &arg2_str;
21866   {
21867     try {
21868       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21869     } catch (std::out_of_range& e) {
21870       {
21871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21872       };
21873     } catch (std::exception& e) {
21874       {
21875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21876       };
21877     } catch (Dali::DaliException e) {
21878       {
21879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21880       };
21881     } catch (...) {
21882       {
21883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21884       };
21885     }
21886   }
21887
21888   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21889
21890   //argout typemap for const std::string&
21891
21892   return jresult;
21893 }
21894
21895
21896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21897   void * jresult ;
21898   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21899   std::type_info *arg2 = 0 ;
21900   Dali::TypeInfo result;
21901
21902   arg1 = (Dali::TypeRegistry *)jarg1;
21903   arg2 = (std::type_info *)jarg2;
21904   if (!arg2) {
21905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21906     return 0;
21907   }
21908   {
21909     try {
21910       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21911     } catch (std::out_of_range& e) {
21912       {
21913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21914       };
21915     } catch (std::exception& e) {
21916       {
21917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21918       };
21919     } catch (Dali::DaliException e) {
21920       {
21921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21922       };
21923     } catch (...) {
21924       {
21925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21926       };
21927     }
21928   }
21929
21930   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21931   return jresult;
21932 }
21933
21934
21935 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21936   unsigned long jresult ;
21937   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21938   size_t result;
21939
21940   arg1 = (Dali::TypeRegistry *)jarg1;
21941   {
21942     try {
21943       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21944     } catch (std::out_of_range& e) {
21945       {
21946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21947       };
21948     } catch (std::exception& e) {
21949       {
21950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21951       };
21952     } catch (Dali::DaliException e) {
21953       {
21954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21955       };
21956     } catch (...) {
21957       {
21958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21959       };
21960     }
21961   }
21962
21963   jresult = (unsigned long)result;
21964   return jresult;
21965 }
21966
21967
21968 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21969   char * jresult ;
21970   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21971   size_t arg2 ;
21972   std::string result;
21973
21974   arg1 = (Dali::TypeRegistry *)jarg1;
21975   arg2 = (size_t)jarg2;
21976   {
21977     try {
21978       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21979     } catch (std::out_of_range& e) {
21980       {
21981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21982       };
21983     } catch (std::exception& e) {
21984       {
21985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21986       };
21987     } catch (Dali::DaliException e) {
21988       {
21989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21990       };
21991     } catch (...) {
21992       {
21993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21994       };
21995     }
21996   }
21997
21998   jresult = SWIG_csharp_string_callback((&result)->c_str());
21999   return jresult;
22000 }
22001
22002
22003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22004   void * jresult ;
22005   std::type_info *arg1 = 0 ;
22006   std::type_info *arg2 = 0 ;
22007   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22008   Dali::TypeRegistration *result = 0 ;
22009
22010   arg1 = (std::type_info *)jarg1;
22011   if (!arg1) {
22012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22013     return 0;
22014   }
22015   arg2 = (std::type_info *)jarg2;
22016   if (!arg2) {
22017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22018     return 0;
22019   }
22020   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22021   {
22022     try {
22023       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22024     } catch (std::out_of_range& e) {
22025       {
22026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22027       };
22028     } catch (std::exception& e) {
22029       {
22030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22031       };
22032     } catch (Dali::DaliException e) {
22033       {
22034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22035       };
22036     } catch (...) {
22037       {
22038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22039       };
22040     }
22041   }
22042
22043   jresult = (void *)result;
22044   return jresult;
22045 }
22046
22047
22048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22049   void * jresult ;
22050   std::type_info *arg1 = 0 ;
22051   std::type_info *arg2 = 0 ;
22052   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22053   bool arg4 ;
22054   Dali::TypeRegistration *result = 0 ;
22055
22056   arg1 = (std::type_info *)jarg1;
22057   if (!arg1) {
22058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22059     return 0;
22060   }
22061   arg2 = (std::type_info *)jarg2;
22062   if (!arg2) {
22063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22064     return 0;
22065   }
22066   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22067   arg4 = jarg4 ? true : false;
22068   {
22069     try {
22070       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22071     } catch (std::out_of_range& e) {
22072       {
22073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22074       };
22075     } catch (std::exception& e) {
22076       {
22077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22078       };
22079     } catch (Dali::DaliException e) {
22080       {
22081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22082       };
22083     } catch (...) {
22084       {
22085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22086       };
22087     }
22088   }
22089
22090   jresult = (void *)result;
22091   return jresult;
22092 }
22093
22094
22095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22096   void * jresult ;
22097   std::string *arg1 = 0 ;
22098   std::type_info *arg2 = 0 ;
22099   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22100   Dali::TypeRegistration *result = 0 ;
22101
22102   if (!jarg1) {
22103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22104     return 0;
22105   }
22106   std::string arg1_str(jarg1);
22107   arg1 = &arg1_str;
22108   arg2 = (std::type_info *)jarg2;
22109   if (!arg2) {
22110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22111     return 0;
22112   }
22113   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22114   {
22115     try {
22116       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22117     } catch (std::out_of_range& e) {
22118       {
22119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22120       };
22121     } catch (std::exception& e) {
22122       {
22123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22124       };
22125     } catch (Dali::DaliException e) {
22126       {
22127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22128       };
22129     } catch (...) {
22130       {
22131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22132       };
22133     }
22134   }
22135
22136   jresult = (void *)result;
22137
22138   //argout typemap for const std::string&
22139
22140   return jresult;
22141 }
22142
22143
22144 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22145   char * jresult ;
22146   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22147   std::string result;
22148
22149   arg1 = (Dali::TypeRegistration *)jarg1;
22150   {
22151     try {
22152       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22153     } catch (std::out_of_range& e) {
22154       {
22155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22156       };
22157     } catch (std::exception& e) {
22158       {
22159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22160       };
22161     } catch (Dali::DaliException e) {
22162       {
22163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22164       };
22165     } catch (...) {
22166       {
22167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22168       };
22169     }
22170   }
22171
22172   jresult = SWIG_csharp_string_callback((&result)->c_str());
22173   return jresult;
22174 }
22175
22176
22177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22178   std::string *arg1 = 0 ;
22179   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22180
22181   if (!jarg1) {
22182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22183     return ;
22184   }
22185   std::string arg1_str(jarg1);
22186   arg1 = &arg1_str;
22187   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22188   {
22189     try {
22190       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22191     } catch (std::out_of_range& e) {
22192       {
22193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22194       };
22195     } catch (std::exception& e) {
22196       {
22197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22198       };
22199     } catch (Dali::DaliException e) {
22200       {
22201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22202       };
22203     } catch (...) {
22204       {
22205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22206       };
22207     }
22208   }
22209
22210
22211   //argout typemap for const std::string&
22212
22213 }
22214
22215
22216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22217   std::string *arg1 = 0 ;
22218   std::string *arg2 = 0 ;
22219   int arg3 ;
22220   Dali::Property::Type arg4 ;
22221   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22222   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22223
22224   if (!jarg1) {
22225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22226     return ;
22227   }
22228   std::string arg1_str(jarg1);
22229   arg1 = &arg1_str;
22230   if (!jarg2) {
22231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22232     return ;
22233   }
22234   std::string arg2_str(jarg2);
22235   arg2 = &arg2_str;
22236   arg3 = (int)jarg3;
22237   arg4 = (Dali::Property::Type)jarg4;
22238   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22239   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22240   {
22241     try {
22242       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22243     } catch (std::out_of_range& e) {
22244       {
22245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22246       };
22247     } catch (std::exception& e) {
22248       {
22249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22250       };
22251     } catch (Dali::DaliException e) {
22252       {
22253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22254       };
22255     } catch (...) {
22256       {
22257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22258       };
22259     }
22260   }
22261
22262
22263   //argout typemap for const std::string&
22264
22265
22266   //argout typemap for const std::string&
22267
22268 }
22269
22270
22271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22272   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22273
22274   arg1 = (Dali::TypeRegistration *)jarg1;
22275   {
22276     try {
22277       delete arg1;
22278     } catch (std::out_of_range& e) {
22279       {
22280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22281       };
22282     } catch (std::exception& e) {
22283       {
22284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22285       };
22286     } catch (Dali::DaliException e) {
22287       {
22288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22289       };
22290     } catch (...) {
22291       {
22292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22293       };
22294     }
22295   }
22296
22297 }
22298
22299
22300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22301   void * jresult ;
22302   Dali::TypeRegistration *arg1 = 0 ;
22303   std::string *arg2 = 0 ;
22304   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22305   Dali::SignalConnectorType *result = 0 ;
22306
22307   arg1 = (Dali::TypeRegistration *)jarg1;
22308   if (!arg1) {
22309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22310     return 0;
22311   }
22312   if (!jarg2) {
22313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22314     return 0;
22315   }
22316   std::string arg2_str(jarg2);
22317   arg2 = &arg2_str;
22318   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22319   {
22320     try {
22321       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22322     } catch (std::out_of_range& e) {
22323       {
22324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22325       };
22326     } catch (std::exception& e) {
22327       {
22328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22329       };
22330     } catch (Dali::DaliException e) {
22331       {
22332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22333       };
22334     } catch (...) {
22335       {
22336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22337       };
22338     }
22339   }
22340
22341   jresult = (void *)result;
22342
22343   //argout typemap for const std::string&
22344
22345   return jresult;
22346 }
22347
22348
22349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22350   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22351
22352   arg1 = (Dali::SignalConnectorType *)jarg1;
22353   {
22354     try {
22355       delete arg1;
22356     } catch (std::out_of_range& e) {
22357       {
22358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22359       };
22360     } catch (std::exception& e) {
22361       {
22362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22363       };
22364     } catch (Dali::DaliException e) {
22365       {
22366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22367       };
22368     } catch (...) {
22369       {
22370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22371       };
22372     }
22373   }
22374
22375 }
22376
22377
22378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22379   void * jresult ;
22380   Dali::TypeRegistration *arg1 = 0 ;
22381   std::string *arg2 = 0 ;
22382   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22383   Dali::TypeAction *result = 0 ;
22384
22385   arg1 = (Dali::TypeRegistration *)jarg1;
22386   if (!arg1) {
22387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22388     return 0;
22389   }
22390   if (!jarg2) {
22391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22392     return 0;
22393   }
22394   std::string arg2_str(jarg2);
22395   arg2 = &arg2_str;
22396   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22397   {
22398     try {
22399       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22400     } catch (std::out_of_range& e) {
22401       {
22402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22403       };
22404     } catch (std::exception& e) {
22405       {
22406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22407       };
22408     } catch (Dali::DaliException e) {
22409       {
22410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22411       };
22412     } catch (...) {
22413       {
22414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22415       };
22416     }
22417   }
22418
22419   jresult = (void *)result;
22420
22421   //argout typemap for const std::string&
22422
22423   return jresult;
22424 }
22425
22426
22427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22428   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22429
22430   arg1 = (Dali::TypeAction *)jarg1;
22431   {
22432     try {
22433       delete arg1;
22434     } catch (std::out_of_range& e) {
22435       {
22436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22437       };
22438     } catch (std::exception& e) {
22439       {
22440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22441       };
22442     } catch (Dali::DaliException e) {
22443       {
22444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22445       };
22446     } catch (...) {
22447       {
22448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22449       };
22450     }
22451   }
22452
22453 }
22454
22455
22456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22457   void * jresult ;
22458   Dali::TypeRegistration *arg1 = 0 ;
22459   std::string *arg2 = 0 ;
22460   Dali::Property::Index arg3 ;
22461   Dali::Property::Type arg4 ;
22462   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22463   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22464   Dali::PropertyRegistration *result = 0 ;
22465
22466   arg1 = (Dali::TypeRegistration *)jarg1;
22467   if (!arg1) {
22468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22469     return 0;
22470   }
22471   if (!jarg2) {
22472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22473     return 0;
22474   }
22475   std::string arg2_str(jarg2);
22476   arg2 = &arg2_str;
22477   arg3 = (Dali::Property::Index)jarg3;
22478   arg4 = (Dali::Property::Type)jarg4;
22479   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22480   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22481   {
22482     try {
22483       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22484     } catch (std::out_of_range& e) {
22485       {
22486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22487       };
22488     } catch (std::exception& e) {
22489       {
22490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22491       };
22492     } catch (Dali::DaliException e) {
22493       {
22494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22495       };
22496     } catch (...) {
22497       {
22498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22499       };
22500     }
22501   }
22502
22503   jresult = (void *)result;
22504
22505   //argout typemap for const std::string&
22506
22507   return jresult;
22508 }
22509
22510
22511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22512   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22513
22514   arg1 = (Dali::PropertyRegistration *)jarg1;
22515   {
22516     try {
22517       delete arg1;
22518     } catch (std::out_of_range& e) {
22519       {
22520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22521       };
22522     } catch (std::exception& e) {
22523       {
22524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22525       };
22526     } catch (Dali::DaliException e) {
22527       {
22528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22529       };
22530     } catch (...) {
22531       {
22532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22533       };
22534     }
22535   }
22536
22537 }
22538
22539
22540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22541   void * jresult ;
22542   Dali::TypeRegistration *arg1 = 0 ;
22543   std::string *arg2 = 0 ;
22544   Dali::Property::Index arg3 ;
22545   Dali::Property::Type arg4 ;
22546   Dali::AnimatablePropertyRegistration *result = 0 ;
22547
22548   arg1 = (Dali::TypeRegistration *)jarg1;
22549   if (!arg1) {
22550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22551     return 0;
22552   }
22553   if (!jarg2) {
22554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22555     return 0;
22556   }
22557   std::string arg2_str(jarg2);
22558   arg2 = &arg2_str;
22559   arg3 = (Dali::Property::Index)jarg3;
22560   arg4 = (Dali::Property::Type)jarg4;
22561   {
22562     try {
22563       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22564     } catch (std::out_of_range& e) {
22565       {
22566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22567       };
22568     } catch (std::exception& e) {
22569       {
22570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22571       };
22572     } catch (Dali::DaliException e) {
22573       {
22574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22575       };
22576     } catch (...) {
22577       {
22578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22579       };
22580     }
22581   }
22582
22583   jresult = (void *)result;
22584
22585   //argout typemap for const std::string&
22586
22587   return jresult;
22588 }
22589
22590
22591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22592   void * jresult ;
22593   Dali::TypeRegistration *arg1 = 0 ;
22594   std::string *arg2 = 0 ;
22595   Dali::Property::Index arg3 ;
22596   Dali::Property::Value *arg4 = 0 ;
22597   Dali::AnimatablePropertyRegistration *result = 0 ;
22598
22599   arg1 = (Dali::TypeRegistration *)jarg1;
22600   if (!arg1) {
22601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22602     return 0;
22603   }
22604   if (!jarg2) {
22605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22606     return 0;
22607   }
22608   std::string arg2_str(jarg2);
22609   arg2 = &arg2_str;
22610   arg3 = (Dali::Property::Index)jarg3;
22611   arg4 = (Dali::Property::Value *)jarg4;
22612   if (!arg4) {
22613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22614     return 0;
22615   }
22616   {
22617     try {
22618       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22619     } catch (std::out_of_range& e) {
22620       {
22621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22622       };
22623     } catch (std::exception& e) {
22624       {
22625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22626       };
22627     } catch (Dali::DaliException e) {
22628       {
22629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22630       };
22631     } catch (...) {
22632       {
22633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22634       };
22635     }
22636   }
22637
22638   jresult = (void *)result;
22639
22640   //argout typemap for const std::string&
22641
22642   return jresult;
22643 }
22644
22645
22646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22647   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22648
22649   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22650   {
22651     try {
22652       delete arg1;
22653     } catch (std::out_of_range& e) {
22654       {
22655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22656       };
22657     } catch (std::exception& e) {
22658       {
22659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22660       };
22661     } catch (Dali::DaliException e) {
22662       {
22663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22664       };
22665     } catch (...) {
22666       {
22667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22668       };
22669     }
22670   }
22671
22672 }
22673
22674
22675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22676   void * jresult ;
22677   Dali::TypeRegistration *arg1 = 0 ;
22678   std::string *arg2 = 0 ;
22679   Dali::Property::Index arg3 ;
22680   Dali::Property::Index arg4 ;
22681   unsigned int arg5 ;
22682   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22683
22684   arg1 = (Dali::TypeRegistration *)jarg1;
22685   if (!arg1) {
22686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22687     return 0;
22688   }
22689   if (!jarg2) {
22690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22691     return 0;
22692   }
22693   std::string arg2_str(jarg2);
22694   arg2 = &arg2_str;
22695   arg3 = (Dali::Property::Index)jarg3;
22696   arg4 = (Dali::Property::Index)jarg4;
22697   arg5 = (unsigned int)jarg5;
22698   {
22699     try {
22700       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22701     } catch (std::out_of_range& e) {
22702       {
22703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22704       };
22705     } catch (std::exception& e) {
22706       {
22707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22708       };
22709     } catch (Dali::DaliException e) {
22710       {
22711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22712       };
22713     } catch (...) {
22714       {
22715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22716       };
22717     }
22718   }
22719
22720   jresult = (void *)result;
22721
22722   //argout typemap for const std::string&
22723
22724   return jresult;
22725 }
22726
22727
22728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22729   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22730
22731   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22732   {
22733     try {
22734       delete arg1;
22735     } catch (std::out_of_range& e) {
22736       {
22737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22738       };
22739     } catch (std::exception& e) {
22740       {
22741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22742       };
22743     } catch (Dali::DaliException e) {
22744       {
22745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22746       };
22747     } catch (...) {
22748       {
22749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22750       };
22751     }
22752   }
22753
22754 }
22755
22756
22757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22758   void * jresult ;
22759   Dali::TypeRegistration *arg1 = 0 ;
22760   std::string *arg2 = 0 ;
22761   Dali::Property::Index arg3 ;
22762   Dali::Property::Type arg4 ;
22763   Dali::ChildPropertyRegistration *result = 0 ;
22764
22765   arg1 = (Dali::TypeRegistration *)jarg1;
22766   if (!arg1) {
22767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22768     return 0;
22769   }
22770   if (!jarg2) {
22771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22772     return 0;
22773   }
22774   std::string arg2_str(jarg2);
22775   arg2 = &arg2_str;
22776   arg3 = (Dali::Property::Index)jarg3;
22777   arg4 = (Dali::Property::Type)jarg4;
22778   {
22779     try {
22780       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22781     } catch (std::out_of_range& e) {
22782       {
22783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22784       };
22785     } catch (std::exception& e) {
22786       {
22787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22788       };
22789     } catch (Dali::DaliException e) {
22790       {
22791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22792       };
22793     } catch (...) {
22794       {
22795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22796       };
22797     }
22798   }
22799
22800   jresult = (void *)result;
22801
22802   //argout typemap for const std::string&
22803
22804   return jresult;
22805 }
22806
22807
22808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22809   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22810
22811   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22812   {
22813     try {
22814       delete arg1;
22815     } catch (std::out_of_range& e) {
22816       {
22817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22818       };
22819     } catch (std::exception& e) {
22820       {
22821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22822       };
22823     } catch (Dali::DaliException e) {
22824       {
22825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22826       };
22827     } catch (...) {
22828       {
22829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22830       };
22831     }
22832   }
22833
22834 }
22835
22836
22837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22838   unsigned int jresult ;
22839   std::string *arg1 = 0 ;
22840   std::type_info *arg2 = 0 ;
22841   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22842   bool result;
22843
22844   if (!jarg1) {
22845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22846     return 0;
22847   }
22848   std::string arg1_str(jarg1);
22849   arg1 = &arg1_str;
22850   arg2 = (std::type_info *)jarg2;
22851   if (!arg2) {
22852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22853     return 0;
22854   }
22855   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22856   {
22857     try {
22858       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22859     } catch (std::out_of_range& e) {
22860       {
22861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22862       };
22863     } catch (std::exception& e) {
22864       {
22865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22866       };
22867     } catch (Dali::DaliException e) {
22868       {
22869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22870       };
22871     } catch (...) {
22872       {
22873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22874       };
22875     }
22876   }
22877
22878   jresult = result;
22879
22880   //argout typemap for const std::string&
22881
22882   return jresult;
22883 }
22884
22885
22886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22887   unsigned int jresult ;
22888   std::string *arg1 = 0 ;
22889   std::string *arg2 = 0 ;
22890   Dali::Property::Index arg3 ;
22891   Dali::Property::Type arg4 ;
22892   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22893   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22894   bool result;
22895
22896   if (!jarg1) {
22897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22898     return 0;
22899   }
22900   std::string arg1_str(jarg1);
22901   arg1 = &arg1_str;
22902   if (!jarg2) {
22903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22904     return 0;
22905   }
22906   std::string arg2_str(jarg2);
22907   arg2 = &arg2_str;
22908   arg3 = (Dali::Property::Index)jarg3;
22909   arg4 = (Dali::Property::Type)jarg4;
22910   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22911   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22912   {
22913     try {
22914       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22915     } catch (std::out_of_range& e) {
22916       {
22917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22918       };
22919     } catch (std::exception& e) {
22920       {
22921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22922       };
22923     } catch (Dali::DaliException e) {
22924       {
22925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22926       };
22927     } catch (...) {
22928       {
22929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22930       };
22931     }
22932   }
22933
22934   jresult = result;
22935
22936   //argout typemap for const std::string&
22937
22938
22939   //argout typemap for const std::string&
22940
22941   return jresult;
22942 }
22943
22944
22945 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22946   float jresult ;
22947   float result;
22948
22949   result = (float)(float)Dali::ParentOrigin::TOP;
22950   jresult = result;
22951   return jresult;
22952 }
22953
22954
22955 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22956   float jresult ;
22957   float result;
22958
22959   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22960   jresult = result;
22961   return jresult;
22962 }
22963
22964
22965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22966   float jresult ;
22967   float result;
22968
22969   result = (float)(float)Dali::ParentOrigin::LEFT;
22970   jresult = result;
22971   return jresult;
22972 }
22973
22974
22975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22976   float jresult ;
22977   float result;
22978
22979   result = (float)(float)Dali::ParentOrigin::RIGHT;
22980   jresult = result;
22981   return jresult;
22982 }
22983
22984
22985 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22986   float jresult ;
22987   float result;
22988
22989   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22990   jresult = result;
22991   return jresult;
22992 }
22993
22994
22995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22996   void * jresult ;
22997   Dali::Vector3 *result = 0 ;
22998
22999   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
23000   jresult = (void *)result;
23001   return jresult;
23002 }
23003
23004
23005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
23006   void * jresult ;
23007   Dali::Vector3 *result = 0 ;
23008
23009   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
23010   jresult = (void *)result;
23011   return jresult;
23012 }
23013
23014
23015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23016   void * jresult ;
23017   Dali::Vector3 *result = 0 ;
23018
23019   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23020   jresult = (void *)result;
23021   return jresult;
23022 }
23023
23024
23025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23026   void * jresult ;
23027   Dali::Vector3 *result = 0 ;
23028
23029   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23030   jresult = (void *)result;
23031   return jresult;
23032 }
23033
23034
23035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23036   void * jresult ;
23037   Dali::Vector3 *result = 0 ;
23038
23039   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23040   jresult = (void *)result;
23041   return jresult;
23042 }
23043
23044
23045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23046   void * jresult ;
23047   Dali::Vector3 *result = 0 ;
23048
23049   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23050   jresult = (void *)result;
23051   return jresult;
23052 }
23053
23054
23055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23056   void * jresult ;
23057   Dali::Vector3 *result = 0 ;
23058
23059   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23060   jresult = (void *)result;
23061   return jresult;
23062 }
23063
23064
23065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23066   void * jresult ;
23067   Dali::Vector3 *result = 0 ;
23068
23069   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23070   jresult = (void *)result;
23071   return jresult;
23072 }
23073
23074
23075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23076   void * jresult ;
23077   Dali::Vector3 *result = 0 ;
23078
23079   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23080   jresult = (void *)result;
23081   return jresult;
23082 }
23083
23084
23085 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23086   float jresult ;
23087   float result;
23088
23089   result = (float)(float)Dali::AnchorPoint::TOP;
23090   jresult = result;
23091   return jresult;
23092 }
23093
23094
23095 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23096   float jresult ;
23097   float result;
23098
23099   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23100   jresult = result;
23101   return jresult;
23102 }
23103
23104
23105 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23106   float jresult ;
23107   float result;
23108
23109   result = (float)(float)Dali::AnchorPoint::LEFT;
23110   jresult = result;
23111   return jresult;
23112 }
23113
23114
23115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23116   float jresult ;
23117   float result;
23118
23119   result = (float)(float)Dali::AnchorPoint::RIGHT;
23120   jresult = result;
23121   return jresult;
23122 }
23123
23124
23125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23126   float jresult ;
23127   float result;
23128
23129   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23130   jresult = result;
23131   return jresult;
23132 }
23133
23134
23135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23136   void * jresult ;
23137   Dali::Vector3 *result = 0 ;
23138
23139   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23140   jresult = (void *)result;
23141   return jresult;
23142 }
23143
23144
23145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23146   void * jresult ;
23147   Dali::Vector3 *result = 0 ;
23148
23149   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23150   jresult = (void *)result;
23151   return jresult;
23152 }
23153
23154
23155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23156   void * jresult ;
23157   Dali::Vector3 *result = 0 ;
23158
23159   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23160   jresult = (void *)result;
23161   return jresult;
23162 }
23163
23164
23165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23166   void * jresult ;
23167   Dali::Vector3 *result = 0 ;
23168
23169   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23170   jresult = (void *)result;
23171   return jresult;
23172 }
23173
23174
23175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23176   void * jresult ;
23177   Dali::Vector3 *result = 0 ;
23178
23179   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23180   jresult = (void *)result;
23181   return jresult;
23182 }
23183
23184
23185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23186   void * jresult ;
23187   Dali::Vector3 *result = 0 ;
23188
23189   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23190   jresult = (void *)result;
23191   return jresult;
23192 }
23193
23194
23195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23196   void * jresult ;
23197   Dali::Vector3 *result = 0 ;
23198
23199   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23200   jresult = (void *)result;
23201   return jresult;
23202 }
23203
23204
23205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23206   void * jresult ;
23207   Dali::Vector3 *result = 0 ;
23208
23209   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23210   jresult = (void *)result;
23211   return jresult;
23212 }
23213
23214
23215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23216   void * jresult ;
23217   Dali::Vector3 *result = 0 ;
23218
23219   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23220   jresult = (void *)result;
23221   return jresult;
23222 }
23223
23224
23225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23226   void * jresult ;
23227   Dali::Vector4 *result = 0 ;
23228
23229   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23230   jresult = (void *)result;
23231   return jresult;
23232 }
23233
23234
23235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23236   void * jresult ;
23237   Dali::Vector4 *result = 0 ;
23238
23239   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23240   jresult = (void *)result;
23241   return jresult;
23242 }
23243
23244
23245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23246   void * jresult ;
23247   Dali::Vector4 *result = 0 ;
23248
23249   result = (Dali::Vector4 *)&Dali::Color::RED;
23250   jresult = (void *)result;
23251   return jresult;
23252 }
23253
23254
23255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23256   void * jresult ;
23257   Dali::Vector4 *result = 0 ;
23258
23259   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23260   jresult = (void *)result;
23261   return jresult;
23262 }
23263
23264
23265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23266   void * jresult ;
23267   Dali::Vector4 *result = 0 ;
23268
23269   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23270   jresult = (void *)result;
23271   return jresult;
23272 }
23273
23274
23275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23276   void * jresult ;
23277   Dali::Vector4 *result = 0 ;
23278
23279   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23280   jresult = (void *)result;
23281   return jresult;
23282 }
23283
23284
23285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23286   void * jresult ;
23287   Dali::Vector4 *result = 0 ;
23288
23289   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23290   jresult = (void *)result;
23291   return jresult;
23292 }
23293
23294
23295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23296   void * jresult ;
23297   Dali::Vector4 *result = 0 ;
23298
23299   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23300   jresult = (void *)result;
23301   return jresult;
23302 }
23303
23304
23305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23306   void * jresult ;
23307   Dali::Vector4 *result = 0 ;
23308
23309   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23310   jresult = (void *)result;
23311   return jresult;
23312 }
23313
23314
23315 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23316   float jresult ;
23317   float result;
23318
23319   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23320   jresult = result;
23321   return jresult;
23322 }
23323
23324
23325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23326   float jresult ;
23327   float result;
23328
23329   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23330   jresult = result;
23331   return jresult;
23332 }
23333
23334
23335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23336   float jresult ;
23337   float result;
23338
23339   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23340   jresult = result;
23341   return jresult;
23342 }
23343
23344
23345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23346   float jresult ;
23347   float result;
23348
23349   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23350   jresult = result;
23351   return jresult;
23352 }
23353
23354
23355 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23356   float jresult ;
23357   float result;
23358
23359   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23360   jresult = result;
23361   return jresult;
23362 }
23363
23364
23365 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23366   float jresult ;
23367   float result;
23368
23369   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23370   jresult = result;
23371   return jresult;
23372 }
23373
23374
23375 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23376   float jresult ;
23377   float result;
23378
23379   result = (float)(float)Dali::Math::PI;
23380   jresult = result;
23381   return jresult;
23382 }
23383
23384
23385 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23386   float jresult ;
23387   float result;
23388
23389   result = (float)(float)Dali::Math::PI_2;
23390   jresult = result;
23391   return jresult;
23392 }
23393
23394
23395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23396   float jresult ;
23397   float result;
23398
23399   result = (float)(float)Dali::Math::PI_4;
23400   jresult = result;
23401   return jresult;
23402 }
23403
23404
23405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23406   float jresult ;
23407   float result;
23408
23409   result = (float)(float)Dali::Math::PI_OVER_180;
23410   jresult = result;
23411   return jresult;
23412 }
23413
23414
23415 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23416   float jresult ;
23417   float result;
23418
23419   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23420   jresult = result;
23421   return jresult;
23422 }
23423
23424
23425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23426   int jresult ;
23427   Dali::ResizePolicy::Type result;
23428
23429   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23430   jresult = (int)result;
23431   return jresult;
23432 }
23433
23434
23435 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23436   unsigned long jresult ;
23437   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23438   Dali::VectorBase::SizeType result;
23439
23440   arg1 = (Dali::VectorBase *)jarg1;
23441   {
23442     try {
23443       result = ((Dali::VectorBase const *)arg1)->Count();
23444     } catch (std::out_of_range& e) {
23445       {
23446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23447       };
23448     } catch (std::exception& e) {
23449       {
23450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23451       };
23452     } catch (Dali::DaliException e) {
23453       {
23454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23455       };
23456     } catch (...) {
23457       {
23458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23459       };
23460     }
23461   }
23462
23463   jresult = (unsigned long)result;
23464   return jresult;
23465 }
23466
23467
23468 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23469   unsigned long jresult ;
23470   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23471   Dali::VectorBase::SizeType result;
23472
23473   arg1 = (Dali::VectorBase *)jarg1;
23474   {
23475     try {
23476       result = ((Dali::VectorBase const *)arg1)->Size();
23477     } catch (std::out_of_range& e) {
23478       {
23479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23480       };
23481     } catch (std::exception& e) {
23482       {
23483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23484       };
23485     } catch (Dali::DaliException e) {
23486       {
23487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23488       };
23489     } catch (...) {
23490       {
23491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23492       };
23493     }
23494   }
23495
23496   jresult = (unsigned long)result;
23497   return jresult;
23498 }
23499
23500
23501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23502   unsigned int jresult ;
23503   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23504   bool result;
23505
23506   arg1 = (Dali::VectorBase *)jarg1;
23507   {
23508     try {
23509       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23510     } catch (std::out_of_range& e) {
23511       {
23512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23513       };
23514     } catch (std::exception& e) {
23515       {
23516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23517       };
23518     } catch (Dali::DaliException e) {
23519       {
23520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23521       };
23522     } catch (...) {
23523       {
23524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23525       };
23526     }
23527   }
23528
23529   jresult = result;
23530   return jresult;
23531 }
23532
23533
23534 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23535   unsigned long jresult ;
23536   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23537   Dali::VectorBase::SizeType result;
23538
23539   arg1 = (Dali::VectorBase *)jarg1;
23540   {
23541     try {
23542       result = ((Dali::VectorBase const *)arg1)->Capacity();
23543     } catch (std::out_of_range& e) {
23544       {
23545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23546       };
23547     } catch (std::exception& e) {
23548       {
23549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23550       };
23551     } catch (Dali::DaliException e) {
23552       {
23553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23554       };
23555     } catch (...) {
23556       {
23557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23558       };
23559     }
23560   }
23561
23562   jresult = (unsigned long)result;
23563   return jresult;
23564 }
23565
23566
23567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23568   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23569
23570   arg1 = (Dali::VectorBase *)jarg1;
23571   {
23572     try {
23573       (arg1)->Release();
23574     } catch (std::out_of_range& e) {
23575       {
23576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23577       };
23578     } catch (std::exception& e) {
23579       {
23580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23581       };
23582     } catch (Dali::DaliException e) {
23583       {
23584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23585       };
23586     } catch (...) {
23587       {
23588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23589       };
23590     }
23591   }
23592
23593 }
23594
23595
23596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23597   int jresult ;
23598   Dali::Pixel::Format result;
23599
23600   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23601   jresult = (int)result;
23602   return jresult;
23603 }
23604
23605
23606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23607   int jresult ;
23608   Dali::Pixel::Format result;
23609
23610   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23611   jresult = (int)result;
23612   return jresult;
23613 }
23614
23615
23616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23617   unsigned int jresult ;
23618   Dali::Pixel::Format arg1 ;
23619   bool result;
23620
23621   arg1 = (Dali::Pixel::Format)jarg1;
23622   {
23623     try {
23624       result = (bool)Dali::Pixel::HasAlpha(arg1);
23625     } catch (std::out_of_range& e) {
23626       {
23627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23628       };
23629     } catch (std::exception& e) {
23630       {
23631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23632       };
23633     } catch (Dali::DaliException e) {
23634       {
23635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23636       };
23637     } catch (...) {
23638       {
23639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23640       };
23641     }
23642   }
23643
23644   jresult = result;
23645   return jresult;
23646 }
23647
23648
23649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23650   unsigned int jresult ;
23651   Dali::Pixel::Format arg1 ;
23652   unsigned int result;
23653
23654   arg1 = (Dali::Pixel::Format)jarg1;
23655   {
23656     try {
23657       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23658     } catch (std::out_of_range& e) {
23659       {
23660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23661       };
23662     } catch (std::exception& e) {
23663       {
23664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23665       };
23666     } catch (Dali::DaliException e) {
23667       {
23668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23669       };
23670     } catch (...) {
23671       {
23672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23673       };
23674     }
23675   }
23676
23677   jresult = result;
23678   return jresult;
23679 }
23680
23681
23682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23683   Dali::Pixel::Format arg1 ;
23684   int *arg2 = 0 ;
23685   int *arg3 = 0 ;
23686
23687   arg1 = (Dali::Pixel::Format)jarg1;
23688   arg2 = (int *)jarg2;
23689   if (!arg2) {
23690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23691     return ;
23692   }
23693   arg3 = (int *)jarg3;
23694   if (!arg3) {
23695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23696     return ;
23697   }
23698   {
23699     try {
23700       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23701     } catch (std::out_of_range& e) {
23702       {
23703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23704       };
23705     } catch (std::exception& e) {
23706       {
23707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23708       };
23709     } catch (Dali::DaliException e) {
23710       {
23711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23712       };
23713     } catch (...) {
23714       {
23715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23716       };
23717     }
23718   }
23719
23720 }
23721
23722
23723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23724   void * jresult ;
23725   unsigned char *arg1 = (unsigned char *) 0 ;
23726   unsigned int arg2 ;
23727   unsigned int arg3 ;
23728   unsigned int arg4 ;
23729   Dali::Pixel::Format arg5 ;
23730   Dali::PixelData::ReleaseFunction arg6 ;
23731   Dali::PixelData result;
23732
23733   arg1 = jarg1;
23734   arg2 = (unsigned int)jarg2;
23735   arg3 = (unsigned int)jarg3;
23736   arg4 = (unsigned int)jarg4;
23737   arg5 = (Dali::Pixel::Format)jarg5;
23738   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23739   {
23740     try {
23741       auto pixelBuffer = new unsigned char[jarg2];
23742       memcpy( pixelBuffer, arg1, arg2);
23743       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23744     } catch (std::out_of_range& e) {
23745       {
23746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23747       };
23748     } catch (std::exception& e) {
23749       {
23750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23751       };
23752     } catch (Dali::DaliException e) {
23753       {
23754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23755       };
23756     } catch (...) {
23757       {
23758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23759       };
23760     }
23761   }
23762
23763   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23764
23765
23766   return jresult;
23767 }
23768
23769
23770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
23771   void * jresult ;
23772   Dali::PixelData *result = 0 ;
23773
23774   {
23775     try {
23776       result = (Dali::PixelData *)new Dali::PixelData();
23777     } catch (std::out_of_range& e) {
23778       {
23779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23780       };
23781     } catch (std::exception& e) {
23782       {
23783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23784       };
23785     } catch (Dali::DaliException e) {
23786       {
23787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23788       };
23789     } catch (...) {
23790       {
23791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23792       };
23793     }
23794   }
23795
23796   jresult = (void *)result;
23797   return jresult;
23798 }
23799
23800
23801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
23802   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23803
23804   arg1 = (Dali::PixelData *)jarg1;
23805   {
23806     try {
23807       delete arg1;
23808     } catch (std::out_of_range& e) {
23809       {
23810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23811       };
23812     } catch (std::exception& e) {
23813       {
23814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23815       };
23816     } catch (Dali::DaliException e) {
23817       {
23818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23819       };
23820     } catch (...) {
23821       {
23822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23823       };
23824     }
23825   }
23826
23827 }
23828
23829
23830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
23831   void * jresult ;
23832   Dali::PixelData *arg1 = 0 ;
23833   Dali::PixelData *result = 0 ;
23834
23835   arg1 = (Dali::PixelData *)jarg1;
23836   if (!arg1) {
23837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23838     return 0;
23839   }
23840   {
23841     try {
23842       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
23843     } catch (std::out_of_range& e) {
23844       {
23845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23846       };
23847     } catch (std::exception& e) {
23848       {
23849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23850       };
23851     } catch (Dali::DaliException e) {
23852       {
23853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23854       };
23855     } catch (...) {
23856       {
23857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23858       };
23859     }
23860   }
23861
23862   jresult = (void *)result;
23863   return jresult;
23864 }
23865
23866
23867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
23868   void * jresult ;
23869   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23870   Dali::PixelData *arg2 = 0 ;
23871   Dali::PixelData *result = 0 ;
23872
23873   arg1 = (Dali::PixelData *)jarg1;
23874   arg2 = (Dali::PixelData *)jarg2;
23875   if (!arg2) {
23876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23877     return 0;
23878   }
23879   {
23880     try {
23881       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
23882     } catch (std::out_of_range& e) {
23883       {
23884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23885       };
23886     } catch (std::exception& e) {
23887       {
23888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23889       };
23890     } catch (Dali::DaliException e) {
23891       {
23892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23893       };
23894     } catch (...) {
23895       {
23896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23897       };
23898     }
23899   }
23900
23901   jresult = (void *)result;
23902   return jresult;
23903 }
23904
23905
23906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
23907   unsigned int jresult ;
23908   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23909   unsigned int result;
23910
23911   arg1 = (Dali::PixelData *)jarg1;
23912   {
23913     try {
23914       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
23915     } catch (std::out_of_range& e) {
23916       {
23917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23918       };
23919     } catch (std::exception& e) {
23920       {
23921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23922       };
23923     } catch (Dali::DaliException e) {
23924       {
23925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23926       };
23927     } catch (...) {
23928       {
23929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23930       };
23931     }
23932   }
23933
23934   jresult = result;
23935   return jresult;
23936 }
23937
23938
23939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
23940   unsigned int jresult ;
23941   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23942   unsigned int result;
23943
23944   arg1 = (Dali::PixelData *)jarg1;
23945   {
23946     try {
23947       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
23948     } catch (std::out_of_range& e) {
23949       {
23950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23951       };
23952     } catch (std::exception& e) {
23953       {
23954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23955       };
23956     } catch (Dali::DaliException e) {
23957       {
23958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23959       };
23960     } catch (...) {
23961       {
23962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23963       };
23964     }
23965   }
23966
23967   jresult = result;
23968   return jresult;
23969 }
23970
23971
23972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
23973   int jresult ;
23974   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23975   Dali::Pixel::Format result;
23976
23977   arg1 = (Dali::PixelData *)jarg1;
23978   {
23979     try {
23980       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
23981     } catch (std::out_of_range& e) {
23982       {
23983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23984       };
23985     } catch (std::exception& e) {
23986       {
23987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23988       };
23989     } catch (Dali::DaliException e) {
23990       {
23991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23992       };
23993     } catch (...) {
23994       {
23995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23996       };
23997     }
23998   }
23999
24000   jresult = (int)result;
24001   return jresult;
24002 }
24003
24004
24005 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24006   unsigned int jresult ;
24007   unsigned int result;
24008
24009   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24010   jresult = result;
24011   return jresult;
24012 }
24013
24014
24015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24016   unsigned int jresult ;
24017   unsigned int result;
24018
24019   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24020   jresult = result;
24021   return jresult;
24022 }
24023
24024
24025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24026   unsigned int jresult ;
24027   unsigned int result;
24028
24029   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24030   jresult = result;
24031   return jresult;
24032 }
24033
24034
24035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24036   unsigned int jresult ;
24037   unsigned int result;
24038
24039   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24040   jresult = result;
24041   return jresult;
24042 }
24043
24044
24045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24046   unsigned int jresult ;
24047   unsigned int result;
24048
24049   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24050   jresult = result;
24051   return jresult;
24052 }
24053
24054
24055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24056   unsigned int jresult ;
24057   unsigned int result;
24058
24059   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24060   jresult = result;
24061   return jresult;
24062 }
24063
24064
24065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24066   void * jresult ;
24067   Dali::TextureType::Type arg1 ;
24068   Dali::Pixel::Format arg2 ;
24069   unsigned int arg3 ;
24070   unsigned int arg4 ;
24071   Dali::Texture result;
24072
24073   arg1 = (Dali::TextureType::Type)jarg1;
24074   arg2 = (Dali::Pixel::Format)jarg2;
24075   arg3 = (unsigned int)jarg3;
24076   arg4 = (unsigned int)jarg4;
24077   {
24078     try {
24079       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24080     } catch (std::out_of_range& e) {
24081       {
24082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24083       };
24084     } catch (std::exception& e) {
24085       {
24086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24087       };
24088     } catch (Dali::DaliException e) {
24089       {
24090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24091       };
24092     } catch (...) {
24093       {
24094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24095       };
24096     }
24097   }
24098
24099   jresult = new Dali::Texture((const Dali::Texture &)result);
24100   return jresult;
24101 }
24102
24103
24104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24105   void * jresult ;
24106   NativeImageInterface *arg1 = 0 ;
24107   Dali::Texture result;
24108
24109   arg1 = (NativeImageInterface *)jarg1;
24110   if (!arg1) {
24111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24112     return 0;
24113   }
24114   {
24115     try {
24116       result = Dali::Texture::New(*arg1);
24117     } catch (std::out_of_range& e) {
24118       {
24119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24120       };
24121     } catch (std::exception& e) {
24122       {
24123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24124       };
24125     } catch (Dali::DaliException e) {
24126       {
24127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24128       };
24129     } catch (...) {
24130       {
24131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24132       };
24133     }
24134   }
24135
24136   jresult = new Dali::Texture((const Dali::Texture &)result);
24137   return jresult;
24138 }
24139
24140
24141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24142   void * jresult ;
24143   Dali::Texture *result = 0 ;
24144
24145   {
24146     try {
24147       result = (Dali::Texture *)new Dali::Texture();
24148     } catch (std::out_of_range& e) {
24149       {
24150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24151       };
24152     } catch (std::exception& e) {
24153       {
24154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24155       };
24156     } catch (Dali::DaliException e) {
24157       {
24158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24159       };
24160     } catch (...) {
24161       {
24162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24163       };
24164     }
24165   }
24166
24167   jresult = (void *)result;
24168   return jresult;
24169 }
24170
24171
24172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24173   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24174
24175   arg1 = (Dali::Texture *)jarg1;
24176   {
24177     try {
24178       delete arg1;
24179     } catch (std::out_of_range& e) {
24180       {
24181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24182       };
24183     } catch (std::exception& e) {
24184       {
24185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24186       };
24187     } catch (Dali::DaliException e) {
24188       {
24189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24190       };
24191     } catch (...) {
24192       {
24193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24194       };
24195     }
24196   }
24197
24198 }
24199
24200
24201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24202   void * jresult ;
24203   Dali::Texture *arg1 = 0 ;
24204   Dali::Texture *result = 0 ;
24205
24206   arg1 = (Dali::Texture *)jarg1;
24207   if (!arg1) {
24208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24209     return 0;
24210   }
24211   {
24212     try {
24213       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24214     } catch (std::out_of_range& e) {
24215       {
24216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24217       };
24218     } catch (std::exception& e) {
24219       {
24220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24221       };
24222     } catch (Dali::DaliException e) {
24223       {
24224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24225       };
24226     } catch (...) {
24227       {
24228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24229       };
24230     }
24231   }
24232
24233   jresult = (void *)result;
24234   return jresult;
24235 }
24236
24237
24238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24239   void * jresult ;
24240   Dali::BaseHandle arg1 ;
24241   Dali::BaseHandle *argp1 ;
24242   Dali::Texture result;
24243
24244   argp1 = (Dali::BaseHandle *)jarg1;
24245   if (!argp1) {
24246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24247     return 0;
24248   }
24249   arg1 = *argp1;
24250   {
24251     try {
24252       result = Dali::Texture::DownCast(arg1);
24253     } catch (std::out_of_range& e) {
24254       {
24255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24256       };
24257     } catch (std::exception& e) {
24258       {
24259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24260       };
24261     } catch (Dali::DaliException e) {
24262       {
24263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24264       };
24265     } catch (...) {
24266       {
24267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24268       };
24269     }
24270   }
24271
24272   jresult = new Dali::Texture((const Dali::Texture &)result);
24273   return jresult;
24274 }
24275
24276
24277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24278   void * jresult ;
24279   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24280   Dali::Texture *arg2 = 0 ;
24281   Dali::Texture *result = 0 ;
24282
24283   arg1 = (Dali::Texture *)jarg1;
24284   arg2 = (Dali::Texture *)jarg2;
24285   if (!arg2) {
24286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24287     return 0;
24288   }
24289   {
24290     try {
24291       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24292     } catch (std::out_of_range& e) {
24293       {
24294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24295       };
24296     } catch (std::exception& e) {
24297       {
24298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24299       };
24300     } catch (Dali::DaliException e) {
24301       {
24302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24303       };
24304     } catch (...) {
24305       {
24306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24307       };
24308     }
24309   }
24310
24311   jresult = (void *)result;
24312   return jresult;
24313 }
24314
24315
24316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24317   unsigned int jresult ;
24318   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24319   Dali::PixelData arg2 ;
24320   Dali::PixelData *argp2 ;
24321   bool result;
24322
24323   arg1 = (Dali::Texture *)jarg1;
24324   argp2 = (Dali::PixelData *)jarg2;
24325   if (!argp2) {
24326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24327     return 0;
24328   }
24329   arg2 = *argp2;
24330   {
24331     try {
24332       result = (bool)(arg1)->Upload(arg2);
24333     } catch (std::out_of_range& e) {
24334       {
24335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24336       };
24337     } catch (std::exception& e) {
24338       {
24339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24340       };
24341     } catch (Dali::DaliException e) {
24342       {
24343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24344       };
24345     } catch (...) {
24346       {
24347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24348       };
24349     }
24350   }
24351
24352   jresult = result;
24353   return jresult;
24354 }
24355
24356
24357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, unsigned int jarg6, unsigned int jarg7, unsigned int jarg8) {
24358   unsigned int jresult ;
24359   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24360   Dali::PixelData arg2 ;
24361   unsigned int arg3 ;
24362   unsigned int arg4 ;
24363   unsigned int arg5 ;
24364   unsigned int arg6 ;
24365   unsigned int arg7 ;
24366   unsigned int arg8 ;
24367   Dali::PixelData *argp2 ;
24368   bool result;
24369
24370   arg1 = (Dali::Texture *)jarg1;
24371   argp2 = (Dali::PixelData *)jarg2;
24372   if (!argp2) {
24373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24374     return 0;
24375   }
24376   arg2 = *argp2;
24377   arg3 = (unsigned int)jarg3;
24378   arg4 = (unsigned int)jarg4;
24379   arg5 = (unsigned int)jarg5;
24380   arg6 = (unsigned int)jarg6;
24381   arg7 = (unsigned int)jarg7;
24382   arg8 = (unsigned int)jarg8;
24383   {
24384     try {
24385       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24386     } catch (std::out_of_range& e) {
24387       {
24388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24389       };
24390     } catch (std::exception& e) {
24391       {
24392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24393       };
24394     } catch (Dali::DaliException e) {
24395       {
24396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24397       };
24398     } catch (...) {
24399       {
24400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24401       };
24402     }
24403   }
24404
24405   jresult = result;
24406   return jresult;
24407 }
24408
24409
24410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24411   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24412
24413   arg1 = (Dali::Texture *)jarg1;
24414   {
24415     try {
24416       (arg1)->GenerateMipmaps();
24417     } catch (std::out_of_range& e) {
24418       {
24419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24420       };
24421     } catch (std::exception& e) {
24422       {
24423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24424       };
24425     } catch (Dali::DaliException e) {
24426       {
24427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24428       };
24429     } catch (...) {
24430       {
24431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24432       };
24433     }
24434   }
24435
24436 }
24437
24438
24439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24440   unsigned int jresult ;
24441   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24442   unsigned int result;
24443
24444   arg1 = (Dali::Texture *)jarg1;
24445   {
24446     try {
24447       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24448     } catch (std::out_of_range& e) {
24449       {
24450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24451       };
24452     } catch (std::exception& e) {
24453       {
24454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24455       };
24456     } catch (Dali::DaliException e) {
24457       {
24458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24459       };
24460     } catch (...) {
24461       {
24462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24463       };
24464     }
24465   }
24466
24467   jresult = result;
24468   return jresult;
24469 }
24470
24471
24472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24473   unsigned int jresult ;
24474   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24475   unsigned int result;
24476
24477   arg1 = (Dali::Texture *)jarg1;
24478   {
24479     try {
24480       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24481     } catch (std::out_of_range& e) {
24482       {
24483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24484       };
24485     } catch (std::exception& e) {
24486       {
24487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24488       };
24489     } catch (Dali::DaliException e) {
24490       {
24491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24492       };
24493     } catch (...) {
24494       {
24495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24496       };
24497     }
24498   }
24499
24500   jresult = result;
24501   return jresult;
24502 }
24503
24504
24505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24506   void * jresult ;
24507   Dali::Sampler result;
24508
24509   {
24510     try {
24511       result = Dali::Sampler::New();
24512     } catch (std::out_of_range& e) {
24513       {
24514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24515       };
24516     } catch (std::exception& e) {
24517       {
24518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24519       };
24520     } catch (Dali::DaliException e) {
24521       {
24522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24523       };
24524     } catch (...) {
24525       {
24526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24527       };
24528     }
24529   }
24530
24531   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24532   return jresult;
24533 }
24534
24535
24536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24537   void * jresult ;
24538   Dali::Sampler *result = 0 ;
24539
24540   {
24541     try {
24542       result = (Dali::Sampler *)new Dali::Sampler();
24543     } catch (std::out_of_range& e) {
24544       {
24545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24546       };
24547     } catch (std::exception& e) {
24548       {
24549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24550       };
24551     } catch (Dali::DaliException e) {
24552       {
24553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24554       };
24555     } catch (...) {
24556       {
24557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24558       };
24559     }
24560   }
24561
24562   jresult = (void *)result;
24563   return jresult;
24564 }
24565
24566
24567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24568   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24569
24570   arg1 = (Dali::Sampler *)jarg1;
24571   {
24572     try {
24573       delete arg1;
24574     } catch (std::out_of_range& e) {
24575       {
24576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24577       };
24578     } catch (std::exception& e) {
24579       {
24580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24581       };
24582     } catch (Dali::DaliException e) {
24583       {
24584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24585       };
24586     } catch (...) {
24587       {
24588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24589       };
24590     }
24591   }
24592
24593 }
24594
24595
24596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24597   void * jresult ;
24598   Dali::Sampler *arg1 = 0 ;
24599   Dali::Sampler *result = 0 ;
24600
24601   arg1 = (Dali::Sampler *)jarg1;
24602   if (!arg1) {
24603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24604     return 0;
24605   }
24606   {
24607     try {
24608       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24609     } catch (std::out_of_range& e) {
24610       {
24611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24612       };
24613     } catch (std::exception& e) {
24614       {
24615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24616       };
24617     } catch (Dali::DaliException e) {
24618       {
24619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24620       };
24621     } catch (...) {
24622       {
24623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24624       };
24625     }
24626   }
24627
24628   jresult = (void *)result;
24629   return jresult;
24630 }
24631
24632
24633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24634   void * jresult ;
24635   Dali::BaseHandle arg1 ;
24636   Dali::BaseHandle *argp1 ;
24637   Dali::Sampler result;
24638
24639   argp1 = (Dali::BaseHandle *)jarg1;
24640   if (!argp1) {
24641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24642     return 0;
24643   }
24644   arg1 = *argp1;
24645   {
24646     try {
24647       result = Dali::Sampler::DownCast(arg1);
24648     } catch (std::out_of_range& e) {
24649       {
24650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24651       };
24652     } catch (std::exception& e) {
24653       {
24654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24655       };
24656     } catch (Dali::DaliException e) {
24657       {
24658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24659       };
24660     } catch (...) {
24661       {
24662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24663       };
24664     }
24665   }
24666
24667   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24668   return jresult;
24669 }
24670
24671
24672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24673   void * jresult ;
24674   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24675   Dali::Sampler *arg2 = 0 ;
24676   Dali::Sampler *result = 0 ;
24677
24678   arg1 = (Dali::Sampler *)jarg1;
24679   arg2 = (Dali::Sampler *)jarg2;
24680   if (!arg2) {
24681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24682     return 0;
24683   }
24684   {
24685     try {
24686       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24687     } catch (std::out_of_range& e) {
24688       {
24689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24690       };
24691     } catch (std::exception& e) {
24692       {
24693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24694       };
24695     } catch (Dali::DaliException e) {
24696       {
24697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24698       };
24699     } catch (...) {
24700       {
24701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24702       };
24703     }
24704   }
24705
24706   jresult = (void *)result;
24707   return jresult;
24708 }
24709
24710
24711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24712   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24713   Dali::FilterMode::Type arg2 ;
24714   Dali::FilterMode::Type arg3 ;
24715
24716   arg1 = (Dali::Sampler *)jarg1;
24717   arg2 = (Dali::FilterMode::Type)jarg2;
24718   arg3 = (Dali::FilterMode::Type)jarg3;
24719   {
24720     try {
24721       (arg1)->SetFilterMode(arg2,arg3);
24722     } catch (std::out_of_range& e) {
24723       {
24724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24725       };
24726     } catch (std::exception& e) {
24727       {
24728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24729       };
24730     } catch (Dali::DaliException e) {
24731       {
24732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24733       };
24734     } catch (...) {
24735       {
24736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24737       };
24738     }
24739   }
24740
24741 }
24742
24743
24744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24745   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24746   Dali::WrapMode::Type arg2 ;
24747   Dali::WrapMode::Type arg3 ;
24748
24749   arg1 = (Dali::Sampler *)jarg1;
24750   arg2 = (Dali::WrapMode::Type)jarg2;
24751   arg3 = (Dali::WrapMode::Type)jarg3;
24752   {
24753     try {
24754       (arg1)->SetWrapMode(arg2,arg3);
24755     } catch (std::out_of_range& e) {
24756       {
24757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24758       };
24759     } catch (std::exception& e) {
24760       {
24761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24762       };
24763     } catch (Dali::DaliException e) {
24764       {
24765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24766       };
24767     } catch (...) {
24768       {
24769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24770       };
24771     }
24772   }
24773
24774 }
24775
24776
24777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
24778   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24779   Dali::WrapMode::Type arg2 ;
24780   Dali::WrapMode::Type arg3 ;
24781   Dali::WrapMode::Type arg4 ;
24782
24783   arg1 = (Dali::Sampler *)jarg1;
24784   arg2 = (Dali::WrapMode::Type)jarg2;
24785   arg3 = (Dali::WrapMode::Type)jarg3;
24786   arg4 = (Dali::WrapMode::Type)jarg4;
24787   {
24788     try {
24789       (arg1)->SetWrapMode(arg2,arg3,arg4);
24790     } catch (std::out_of_range& e) {
24791       {
24792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24793       };
24794     } catch (std::exception& e) {
24795       {
24796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24797       };
24798     } catch (Dali::DaliException e) {
24799       {
24800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24801       };
24802     } catch (...) {
24803       {
24804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24805       };
24806     }
24807   }
24808
24809 }
24810
24811
24812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
24813   void * jresult ;
24814   Dali::TextureSet result;
24815
24816   {
24817     try {
24818       result = Dali::TextureSet::New();
24819     } catch (std::out_of_range& e) {
24820       {
24821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24822       };
24823     } catch (std::exception& e) {
24824       {
24825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24826       };
24827     } catch (Dali::DaliException e) {
24828       {
24829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24830       };
24831     } catch (...) {
24832       {
24833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24834       };
24835     }
24836   }
24837
24838   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24839   return jresult;
24840 }
24841
24842
24843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
24844   void * jresult ;
24845   Dali::TextureSet *result = 0 ;
24846
24847   {
24848     try {
24849       result = (Dali::TextureSet *)new Dali::TextureSet();
24850     } catch (std::out_of_range& e) {
24851       {
24852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24853       };
24854     } catch (std::exception& e) {
24855       {
24856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24857       };
24858     } catch (Dali::DaliException e) {
24859       {
24860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24861       };
24862     } catch (...) {
24863       {
24864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24865       };
24866     }
24867   }
24868
24869   jresult = (void *)result;
24870   return jresult;
24871 }
24872
24873
24874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
24875   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24876
24877   arg1 = (Dali::TextureSet *)jarg1;
24878   {
24879     try {
24880       delete arg1;
24881     } catch (std::out_of_range& e) {
24882       {
24883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24884       };
24885     } catch (std::exception& e) {
24886       {
24887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24888       };
24889     } catch (Dali::DaliException e) {
24890       {
24891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24892       };
24893     } catch (...) {
24894       {
24895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24896       };
24897     }
24898   }
24899
24900 }
24901
24902
24903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
24904   void * jresult ;
24905   Dali::TextureSet *arg1 = 0 ;
24906   Dali::TextureSet *result = 0 ;
24907
24908   arg1 = (Dali::TextureSet *)jarg1;
24909   if (!arg1) {
24910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24911     return 0;
24912   }
24913   {
24914     try {
24915       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
24916     } catch (std::out_of_range& e) {
24917       {
24918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24919       };
24920     } catch (std::exception& e) {
24921       {
24922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24923       };
24924     } catch (Dali::DaliException e) {
24925       {
24926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24927       };
24928     } catch (...) {
24929       {
24930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24931       };
24932     }
24933   }
24934
24935   jresult = (void *)result;
24936   return jresult;
24937 }
24938
24939
24940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
24941   void * jresult ;
24942   Dali::BaseHandle arg1 ;
24943   Dali::BaseHandle *argp1 ;
24944   Dali::TextureSet result;
24945
24946   argp1 = (Dali::BaseHandle *)jarg1;
24947   if (!argp1) {
24948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24949     return 0;
24950   }
24951   arg1 = *argp1;
24952   {
24953     try {
24954       result = Dali::TextureSet::DownCast(arg1);
24955     } catch (std::out_of_range& e) {
24956       {
24957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24958       };
24959     } catch (std::exception& e) {
24960       {
24961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24962       };
24963     } catch (Dali::DaliException e) {
24964       {
24965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24966       };
24967     } catch (...) {
24968       {
24969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24970       };
24971     }
24972   }
24973
24974   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24975   return jresult;
24976 }
24977
24978
24979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
24980   void * jresult ;
24981   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24982   Dali::TextureSet *arg2 = 0 ;
24983   Dali::TextureSet *result = 0 ;
24984
24985   arg1 = (Dali::TextureSet *)jarg1;
24986   arg2 = (Dali::TextureSet *)jarg2;
24987   if (!arg2) {
24988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24989     return 0;
24990   }
24991   {
24992     try {
24993       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
24994     } catch (std::out_of_range& e) {
24995       {
24996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24997       };
24998     } catch (std::exception& e) {
24999       {
25000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25001       };
25002     } catch (Dali::DaliException e) {
25003       {
25004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25005       };
25006     } catch (...) {
25007       {
25008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25009       };
25010     }
25011   }
25012
25013   jresult = (void *)result;
25014   return jresult;
25015 }
25016
25017
25018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25019   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25020   size_t arg2 ;
25021   Dali::Texture arg3 ;
25022   Dali::Texture *argp3 ;
25023
25024   arg1 = (Dali::TextureSet *)jarg1;
25025   arg2 = (size_t)jarg2;
25026   argp3 = (Dali::Texture *)jarg3;
25027   if (!argp3) {
25028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25029     return ;
25030   }
25031   arg3 = *argp3;
25032   {
25033     try {
25034       (arg1)->SetTexture(arg2,arg3);
25035     } catch (std::out_of_range& e) {
25036       {
25037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25038       };
25039     } catch (std::exception& e) {
25040       {
25041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25042       };
25043     } catch (Dali::DaliException e) {
25044       {
25045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25046       };
25047     } catch (...) {
25048       {
25049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25050       };
25051     }
25052   }
25053
25054 }
25055
25056
25057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25058   void * jresult ;
25059   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25060   size_t arg2 ;
25061   Dali::Texture result;
25062
25063   arg1 = (Dali::TextureSet *)jarg1;
25064   arg2 = (size_t)jarg2;
25065   {
25066     try {
25067       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25068     } catch (std::out_of_range& e) {
25069       {
25070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25071       };
25072     } catch (std::exception& e) {
25073       {
25074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25075       };
25076     } catch (Dali::DaliException e) {
25077       {
25078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25079       };
25080     } catch (...) {
25081       {
25082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25083       };
25084     }
25085   }
25086
25087   jresult = new Dali::Texture((const Dali::Texture &)result);
25088   return jresult;
25089 }
25090
25091
25092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25093   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25094   size_t arg2 ;
25095   Dali::Sampler arg3 ;
25096   Dali::Sampler *argp3 ;
25097
25098   arg1 = (Dali::TextureSet *)jarg1;
25099   arg2 = (size_t)jarg2;
25100   argp3 = (Dali::Sampler *)jarg3;
25101   if (!argp3) {
25102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25103     return ;
25104   }
25105   arg3 = *argp3;
25106   {
25107     try {
25108       (arg1)->SetSampler(arg2,arg3);
25109     } catch (std::out_of_range& e) {
25110       {
25111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25112       };
25113     } catch (std::exception& e) {
25114       {
25115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25116       };
25117     } catch (Dali::DaliException e) {
25118       {
25119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25120       };
25121     } catch (...) {
25122       {
25123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25124       };
25125     }
25126   }
25127
25128 }
25129
25130
25131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25132   void * jresult ;
25133   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25134   size_t arg2 ;
25135   Dali::Sampler result;
25136
25137   arg1 = (Dali::TextureSet *)jarg1;
25138   arg2 = (size_t)jarg2;
25139   {
25140     try {
25141       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25142     } catch (std::out_of_range& e) {
25143       {
25144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25145       };
25146     } catch (std::exception& e) {
25147       {
25148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25149       };
25150     } catch (Dali::DaliException e) {
25151       {
25152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25153       };
25154     } catch (...) {
25155       {
25156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25157       };
25158     }
25159   }
25160
25161   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25162   return jresult;
25163 }
25164
25165
25166 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25167   unsigned long jresult ;
25168   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25169   size_t result;
25170
25171   arg1 = (Dali::TextureSet *)jarg1;
25172   {
25173     try {
25174       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25175     } catch (std::out_of_range& e) {
25176       {
25177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25178       };
25179     } catch (std::exception& e) {
25180       {
25181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25182       };
25183     } catch (Dali::DaliException e) {
25184       {
25185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25186       };
25187     } catch (...) {
25188       {
25189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25190       };
25191     }
25192   }
25193
25194   jresult = (unsigned long)result;
25195   return jresult;
25196 }
25197
25198
25199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25200   void * jresult ;
25201   Dali::Property::Map *arg1 = 0 ;
25202   Dali::PropertyBuffer result;
25203
25204   arg1 = (Dali::Property::Map *)jarg1;
25205   if (!arg1) {
25206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25207     return 0;
25208   }
25209   {
25210     try {
25211       result = Dali::PropertyBuffer::New(*arg1);
25212     } catch (std::out_of_range& e) {
25213       {
25214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25215       };
25216     } catch (std::exception& e) {
25217       {
25218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25219       };
25220     } catch (Dali::DaliException e) {
25221       {
25222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25223       };
25224     } catch (...) {
25225       {
25226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25227       };
25228     }
25229   }
25230
25231   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25232   return jresult;
25233 }
25234
25235
25236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25237   void * jresult ;
25238   Dali::PropertyBuffer *result = 0 ;
25239
25240   {
25241     try {
25242       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25243     } catch (std::out_of_range& e) {
25244       {
25245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25246       };
25247     } catch (std::exception& e) {
25248       {
25249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25250       };
25251     } catch (Dali::DaliException e) {
25252       {
25253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25254       };
25255     } catch (...) {
25256       {
25257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25258       };
25259     }
25260   }
25261
25262   jresult = (void *)result;
25263   return jresult;
25264 }
25265
25266
25267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25268   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25269
25270   arg1 = (Dali::PropertyBuffer *)jarg1;
25271   {
25272     try {
25273       delete arg1;
25274     } catch (std::out_of_range& e) {
25275       {
25276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25277       };
25278     } catch (std::exception& e) {
25279       {
25280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25281       };
25282     } catch (Dali::DaliException e) {
25283       {
25284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25285       };
25286     } catch (...) {
25287       {
25288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25289       };
25290     }
25291   }
25292
25293 }
25294
25295
25296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25297   void * jresult ;
25298   Dali::PropertyBuffer *arg1 = 0 ;
25299   Dali::PropertyBuffer *result = 0 ;
25300
25301   arg1 = (Dali::PropertyBuffer *)jarg1;
25302   if (!arg1) {
25303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25304     return 0;
25305   }
25306   {
25307     try {
25308       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25309     } catch (std::out_of_range& e) {
25310       {
25311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25312       };
25313     } catch (std::exception& e) {
25314       {
25315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25316       };
25317     } catch (Dali::DaliException e) {
25318       {
25319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25320       };
25321     } catch (...) {
25322       {
25323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25324       };
25325     }
25326   }
25327
25328   jresult = (void *)result;
25329   return jresult;
25330 }
25331
25332
25333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25334   void * jresult ;
25335   Dali::BaseHandle arg1 ;
25336   Dali::BaseHandle *argp1 ;
25337   Dali::PropertyBuffer result;
25338
25339   argp1 = (Dali::BaseHandle *)jarg1;
25340   if (!argp1) {
25341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25342     return 0;
25343   }
25344   arg1 = *argp1;
25345   {
25346     try {
25347       result = Dali::PropertyBuffer::DownCast(arg1);
25348     } catch (std::out_of_range& e) {
25349       {
25350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25351       };
25352     } catch (std::exception& e) {
25353       {
25354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25355       };
25356     } catch (Dali::DaliException e) {
25357       {
25358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25359       };
25360     } catch (...) {
25361       {
25362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25363       };
25364     }
25365   }
25366
25367   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25368   return jresult;
25369 }
25370
25371
25372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25373   void * jresult ;
25374   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25375   Dali::PropertyBuffer *arg2 = 0 ;
25376   Dali::PropertyBuffer *result = 0 ;
25377
25378   arg1 = (Dali::PropertyBuffer *)jarg1;
25379   arg2 = (Dali::PropertyBuffer *)jarg2;
25380   if (!arg2) {
25381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25382     return 0;
25383   }
25384   {
25385     try {
25386       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25387     } catch (std::out_of_range& e) {
25388       {
25389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25390       };
25391     } catch (std::exception& e) {
25392       {
25393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25394       };
25395     } catch (Dali::DaliException e) {
25396       {
25397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25398       };
25399     } catch (...) {
25400       {
25401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25402       };
25403     }
25404   }
25405
25406   jresult = (void *)result;
25407   return jresult;
25408 }
25409
25410
25411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25412   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25413   void *arg2 = (void *) 0 ;
25414   std::size_t arg3 ;
25415
25416   arg1 = (Dali::PropertyBuffer *)jarg1;
25417   arg2 = jarg2;
25418   arg3 = (std::size_t)jarg3;
25419   {
25420     try {
25421       (arg1)->SetData((void const *)arg2,arg3);
25422     } catch (std::out_of_range& e) {
25423       {
25424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25425       };
25426     } catch (std::exception& e) {
25427       {
25428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25429       };
25430     } catch (Dali::DaliException e) {
25431       {
25432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25433       };
25434     } catch (...) {
25435       {
25436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25437       };
25438     }
25439   }
25440
25441 }
25442
25443
25444 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25445   unsigned long jresult ;
25446   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25447   std::size_t result;
25448
25449   arg1 = (Dali::PropertyBuffer *)jarg1;
25450   {
25451     try {
25452       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25453     } catch (std::out_of_range& e) {
25454       {
25455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25456       };
25457     } catch (std::exception& e) {
25458       {
25459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25460       };
25461     } catch (Dali::DaliException e) {
25462       {
25463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25464       };
25465     } catch (...) {
25466       {
25467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25468       };
25469     }
25470   }
25471
25472   jresult = (unsigned long)result;
25473   return jresult;
25474 }
25475
25476
25477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25478   void * jresult ;
25479   Dali::Geometry result;
25480
25481   {
25482     try {
25483       result = Dali::Geometry::New();
25484     } catch (std::out_of_range& e) {
25485       {
25486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25487       };
25488     } catch (std::exception& e) {
25489       {
25490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25491       };
25492     } catch (Dali::DaliException e) {
25493       {
25494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25495       };
25496     } catch (...) {
25497       {
25498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25499       };
25500     }
25501   }
25502
25503   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25504   return jresult;
25505 }
25506
25507
25508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25509   void * jresult ;
25510   Dali::Geometry *result = 0 ;
25511
25512   {
25513     try {
25514       result = (Dali::Geometry *)new Dali::Geometry();
25515     } catch (std::out_of_range& e) {
25516       {
25517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25518       };
25519     } catch (std::exception& e) {
25520       {
25521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25522       };
25523     } catch (Dali::DaliException e) {
25524       {
25525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25526       };
25527     } catch (...) {
25528       {
25529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25530       };
25531     }
25532   }
25533
25534   jresult = (void *)result;
25535   return jresult;
25536 }
25537
25538
25539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25540   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25541
25542   arg1 = (Dali::Geometry *)jarg1;
25543   {
25544     try {
25545       delete arg1;
25546     } catch (std::out_of_range& e) {
25547       {
25548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25549       };
25550     } catch (std::exception& e) {
25551       {
25552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25553       };
25554     } catch (Dali::DaliException e) {
25555       {
25556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25557       };
25558     } catch (...) {
25559       {
25560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25561       };
25562     }
25563   }
25564
25565 }
25566
25567
25568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25569   void * jresult ;
25570   Dali::Geometry *arg1 = 0 ;
25571   Dali::Geometry *result = 0 ;
25572
25573   arg1 = (Dali::Geometry *)jarg1;
25574   if (!arg1) {
25575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25576     return 0;
25577   }
25578   {
25579     try {
25580       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25581     } catch (std::out_of_range& e) {
25582       {
25583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25584       };
25585     } catch (std::exception& e) {
25586       {
25587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25588       };
25589     } catch (Dali::DaliException e) {
25590       {
25591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25592       };
25593     } catch (...) {
25594       {
25595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25596       };
25597     }
25598   }
25599
25600   jresult = (void *)result;
25601   return jresult;
25602 }
25603
25604
25605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25606   void * jresult ;
25607   Dali::BaseHandle arg1 ;
25608   Dali::BaseHandle *argp1 ;
25609   Dali::Geometry result;
25610
25611   argp1 = (Dali::BaseHandle *)jarg1;
25612   if (!argp1) {
25613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25614     return 0;
25615   }
25616   arg1 = *argp1;
25617   {
25618     try {
25619       result = Dali::Geometry::DownCast(arg1);
25620     } catch (std::out_of_range& e) {
25621       {
25622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25623       };
25624     } catch (std::exception& e) {
25625       {
25626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25627       };
25628     } catch (Dali::DaliException e) {
25629       {
25630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25631       };
25632     } catch (...) {
25633       {
25634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25635       };
25636     }
25637   }
25638
25639   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25640   return jresult;
25641 }
25642
25643
25644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25645   void * jresult ;
25646   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25647   Dali::Geometry *arg2 = 0 ;
25648   Dali::Geometry *result = 0 ;
25649
25650   arg1 = (Dali::Geometry *)jarg1;
25651   arg2 = (Dali::Geometry *)jarg2;
25652   if (!arg2) {
25653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25654     return 0;
25655   }
25656   {
25657     try {
25658       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25659     } catch (std::out_of_range& e) {
25660       {
25661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25662       };
25663     } catch (std::exception& e) {
25664       {
25665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25666       };
25667     } catch (Dali::DaliException e) {
25668       {
25669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25670       };
25671     } catch (...) {
25672       {
25673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25674       };
25675     }
25676   }
25677
25678   jresult = (void *)result;
25679   return jresult;
25680 }
25681
25682
25683 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25684   unsigned long jresult ;
25685   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25686   Dali::PropertyBuffer *arg2 = 0 ;
25687   std::size_t result;
25688
25689   arg1 = (Dali::Geometry *)jarg1;
25690   arg2 = (Dali::PropertyBuffer *)jarg2;
25691   if (!arg2) {
25692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25693     return 0;
25694   }
25695   {
25696     try {
25697       result = (arg1)->AddVertexBuffer(*arg2);
25698     } catch (std::out_of_range& e) {
25699       {
25700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25701       };
25702     } catch (std::exception& e) {
25703       {
25704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25705       };
25706     } catch (Dali::DaliException e) {
25707       {
25708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25709       };
25710     } catch (...) {
25711       {
25712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25713       };
25714     }
25715   }
25716
25717   jresult = (unsigned long)result;
25718   return jresult;
25719 }
25720
25721
25722 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25723   unsigned long jresult ;
25724   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25725   std::size_t result;
25726
25727   arg1 = (Dali::Geometry *)jarg1;
25728   {
25729     try {
25730       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25731     } catch (std::out_of_range& e) {
25732       {
25733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25734       };
25735     } catch (std::exception& e) {
25736       {
25737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25738       };
25739     } catch (Dali::DaliException e) {
25740       {
25741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25742       };
25743     } catch (...) {
25744       {
25745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25746       };
25747     }
25748   }
25749
25750   jresult = (unsigned long)result;
25751   return jresult;
25752 }
25753
25754
25755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25756   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25757   std::size_t arg2 ;
25758
25759   arg1 = (Dali::Geometry *)jarg1;
25760   arg2 = (std::size_t)jarg2;
25761   {
25762     try {
25763       (arg1)->RemoveVertexBuffer(arg2);
25764     } catch (std::out_of_range& e) {
25765       {
25766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25767       };
25768     } catch (std::exception& e) {
25769       {
25770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25771       };
25772     } catch (Dali::DaliException e) {
25773       {
25774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25775       };
25776     } catch (...) {
25777       {
25778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25779       };
25780     }
25781   }
25782
25783 }
25784
25785
25786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
25787   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25788   unsigned short *arg2 = (unsigned short *) 0 ;
25789   size_t arg3 ;
25790
25791   arg1 = (Dali::Geometry *)jarg1;
25792   arg2 = jarg2;
25793   arg3 = (size_t)jarg3;
25794   {
25795     try {
25796       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
25797     } catch (std::out_of_range& e) {
25798       {
25799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25800       };
25801     } catch (std::exception& e) {
25802       {
25803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25804       };
25805     } catch (Dali::DaliException e) {
25806       {
25807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25808       };
25809     } catch (...) {
25810       {
25811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25812       };
25813     }
25814   }
25815
25816
25817
25818 }
25819
25820
25821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
25822   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25823   Dali::Geometry::Type arg2 ;
25824
25825   arg1 = (Dali::Geometry *)jarg1;
25826   arg2 = (Dali::Geometry::Type)jarg2;
25827   {
25828     try {
25829       (arg1)->SetType(arg2);
25830     } catch (std::out_of_range& e) {
25831       {
25832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25833       };
25834     } catch (std::exception& e) {
25835       {
25836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25837       };
25838     } catch (Dali::DaliException e) {
25839       {
25840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25841       };
25842     } catch (...) {
25843       {
25844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25845       };
25846     }
25847   }
25848
25849 }
25850
25851
25852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
25853   int jresult ;
25854   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25855   Dali::Geometry::Type result;
25856
25857   arg1 = (Dali::Geometry *)jarg1;
25858   {
25859     try {
25860       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
25861     } catch (std::out_of_range& e) {
25862       {
25863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25864       };
25865     } catch (std::exception& e) {
25866       {
25867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25868       };
25869     } catch (Dali::DaliException e) {
25870       {
25871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25872       };
25873     } catch (...) {
25874       {
25875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25876       };
25877     }
25878   }
25879
25880   jresult = (int)result;
25881   return jresult;
25882 }
25883
25884
25885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
25886   void * jresult ;
25887   Dali::Shader::Hint *result = 0 ;
25888
25889   {
25890     try {
25891       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
25892     } catch (std::out_of_range& e) {
25893       {
25894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25895       };
25896     } catch (std::exception& e) {
25897       {
25898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25899       };
25900     } catch (Dali::DaliException e) {
25901       {
25902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25903       };
25904     } catch (...) {
25905       {
25906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25907       };
25908     }
25909   }
25910
25911   jresult = (void *)result;
25912   return jresult;
25913 }
25914
25915
25916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
25917   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
25918
25919   arg1 = (Dali::Shader::Hint *)jarg1;
25920   {
25921     try {
25922       delete arg1;
25923     } catch (std::out_of_range& e) {
25924       {
25925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25926       };
25927     } catch (std::exception& e) {
25928       {
25929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25930       };
25931     } catch (Dali::DaliException e) {
25932       {
25933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25934       };
25935     } catch (...) {
25936       {
25937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25938       };
25939     }
25940   }
25941
25942 }
25943
25944
25945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
25946   int jresult ;
25947   int result;
25948
25949   result = (int)Dali::Shader::Property::PROGRAM;
25950   jresult = (int)result;
25951   return jresult;
25952 }
25953
25954
25955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
25956   void * jresult ;
25957   Dali::Shader::Property *result = 0 ;
25958
25959   {
25960     try {
25961       result = (Dali::Shader::Property *)new Dali::Shader::Property();
25962     } catch (std::out_of_range& e) {
25963       {
25964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25965       };
25966     } catch (std::exception& e) {
25967       {
25968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25969       };
25970     } catch (Dali::DaliException e) {
25971       {
25972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25973       };
25974     } catch (...) {
25975       {
25976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25977       };
25978     }
25979   }
25980
25981   jresult = (void *)result;
25982   return jresult;
25983 }
25984
25985
25986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
25987   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
25988
25989   arg1 = (Dali::Shader::Property *)jarg1;
25990   {
25991     try {
25992       delete arg1;
25993     } catch (std::out_of_range& e) {
25994       {
25995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25996       };
25997     } catch (std::exception& e) {
25998       {
25999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26000       };
26001     } catch (Dali::DaliException e) {
26002       {
26003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26004       };
26005     } catch (...) {
26006       {
26007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26008       };
26009     }
26010   }
26011
26012 }
26013
26014
26015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26016   void * jresult ;
26017   std::string *arg1 = 0 ;
26018   std::string *arg2 = 0 ;
26019   Dali::Shader::Hint::Value arg3 ;
26020   Dali::Shader result;
26021
26022   if (!jarg1) {
26023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26024     return 0;
26025   }
26026   std::string arg1_str(jarg1);
26027   arg1 = &arg1_str;
26028   if (!jarg2) {
26029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26030     return 0;
26031   }
26032   std::string arg2_str(jarg2);
26033   arg2 = &arg2_str;
26034   arg3 = (Dali::Shader::Hint::Value)jarg3;
26035   {
26036     try {
26037       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26038     } catch (std::out_of_range& e) {
26039       {
26040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26041       };
26042     } catch (std::exception& e) {
26043       {
26044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26045       };
26046     } catch (Dali::DaliException e) {
26047       {
26048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26049       };
26050     } catch (...) {
26051       {
26052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26053       };
26054     }
26055   }
26056
26057   jresult = new Dali::Shader((const Dali::Shader &)result);
26058
26059   //argout typemap for const std::string&
26060
26061
26062   //argout typemap for const std::string&
26063
26064   return jresult;
26065 }
26066
26067
26068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26069   void * jresult ;
26070   std::string *arg1 = 0 ;
26071   std::string *arg2 = 0 ;
26072   Dali::Shader result;
26073
26074   if (!jarg1) {
26075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26076     return 0;
26077   }
26078   std::string arg1_str(jarg1);
26079   arg1 = &arg1_str;
26080   if (!jarg2) {
26081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26082     return 0;
26083   }
26084   std::string arg2_str(jarg2);
26085   arg2 = &arg2_str;
26086   {
26087     try {
26088       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26089     } catch (std::out_of_range& e) {
26090       {
26091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26092       };
26093     } catch (std::exception& e) {
26094       {
26095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26096       };
26097     } catch (Dali::DaliException e) {
26098       {
26099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26100       };
26101     } catch (...) {
26102       {
26103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26104       };
26105     }
26106   }
26107
26108   jresult = new Dali::Shader((const Dali::Shader &)result);
26109
26110   //argout typemap for const std::string&
26111
26112
26113   //argout typemap for const std::string&
26114
26115   return jresult;
26116 }
26117
26118
26119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26120   void * jresult ;
26121   Dali::Shader *result = 0 ;
26122
26123   {
26124     try {
26125       result = (Dali::Shader *)new Dali::Shader();
26126     } catch (std::out_of_range& e) {
26127       {
26128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26129       };
26130     } catch (std::exception& e) {
26131       {
26132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26133       };
26134     } catch (Dali::DaliException e) {
26135       {
26136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26137       };
26138     } catch (...) {
26139       {
26140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26141       };
26142     }
26143   }
26144
26145   jresult = (void *)result;
26146   return jresult;
26147 }
26148
26149
26150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26151   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26152
26153   arg1 = (Dali::Shader *)jarg1;
26154   {
26155     try {
26156       delete arg1;
26157     } catch (std::out_of_range& e) {
26158       {
26159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26160       };
26161     } catch (std::exception& e) {
26162       {
26163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26164       };
26165     } catch (Dali::DaliException e) {
26166       {
26167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26168       };
26169     } catch (...) {
26170       {
26171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26172       };
26173     }
26174   }
26175
26176 }
26177
26178
26179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26180   void * jresult ;
26181   Dali::Shader *arg1 = 0 ;
26182   Dali::Shader *result = 0 ;
26183
26184   arg1 = (Dali::Shader *)jarg1;
26185   if (!arg1) {
26186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26187     return 0;
26188   }
26189   {
26190     try {
26191       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26192     } catch (std::out_of_range& e) {
26193       {
26194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26195       };
26196     } catch (std::exception& e) {
26197       {
26198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26199       };
26200     } catch (Dali::DaliException e) {
26201       {
26202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26203       };
26204     } catch (...) {
26205       {
26206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26207       };
26208     }
26209   }
26210
26211   jresult = (void *)result;
26212   return jresult;
26213 }
26214
26215
26216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26217   void * jresult ;
26218   Dali::BaseHandle arg1 ;
26219   Dali::BaseHandle *argp1 ;
26220   Dali::Shader result;
26221
26222   argp1 = (Dali::BaseHandle *)jarg1;
26223   if (!argp1) {
26224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26225     return 0;
26226   }
26227   arg1 = *argp1;
26228   {
26229     try {
26230       result = Dali::Shader::DownCast(arg1);
26231     } catch (std::out_of_range& e) {
26232       {
26233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26234       };
26235     } catch (std::exception& e) {
26236       {
26237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26238       };
26239     } catch (Dali::DaliException e) {
26240       {
26241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26242       };
26243     } catch (...) {
26244       {
26245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26246       };
26247     }
26248   }
26249
26250   jresult = new Dali::Shader((const Dali::Shader &)result);
26251   return jresult;
26252 }
26253
26254
26255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26256   void * jresult ;
26257   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26258   Dali::Shader *arg2 = 0 ;
26259   Dali::Shader *result = 0 ;
26260
26261   arg1 = (Dali::Shader *)jarg1;
26262   arg2 = (Dali::Shader *)jarg2;
26263   if (!arg2) {
26264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26265     return 0;
26266   }
26267   {
26268     try {
26269       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26270     } catch (std::out_of_range& e) {
26271       {
26272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26273       };
26274     } catch (std::exception& e) {
26275       {
26276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26277       };
26278     } catch (Dali::DaliException e) {
26279       {
26280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26281       };
26282     } catch (...) {
26283       {
26284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26285       };
26286     }
26287   }
26288
26289   jresult = (void *)result;
26290   return jresult;
26291 }
26292
26293
26294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26295   int jresult ;
26296   int result;
26297
26298   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26299   jresult = (int)result;
26300   return jresult;
26301 }
26302
26303
26304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26305   int jresult ;
26306   int result;
26307
26308   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26309   jresult = (int)result;
26310   return jresult;
26311 }
26312
26313
26314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26315   int jresult ;
26316   int result;
26317
26318   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26319   jresult = (int)result;
26320   return jresult;
26321 }
26322
26323
26324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26325   int jresult ;
26326   int result;
26327
26328   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26329   jresult = (int)result;
26330   return jresult;
26331 }
26332
26333
26334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26335   int jresult ;
26336   int result;
26337
26338   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26339   jresult = (int)result;
26340   return jresult;
26341 }
26342
26343
26344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26345   int jresult ;
26346   int result;
26347
26348   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26349   jresult = (int)result;
26350   return jresult;
26351 }
26352
26353
26354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26355   int jresult ;
26356   int result;
26357
26358   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26359   jresult = (int)result;
26360   return jresult;
26361 }
26362
26363
26364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26365   int jresult ;
26366   int result;
26367
26368   result = (int)Dali::Renderer::Property::BLEND_MODE;
26369   jresult = (int)result;
26370   return jresult;
26371 }
26372
26373
26374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26375   int jresult ;
26376   int result;
26377
26378   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26379   jresult = (int)result;
26380   return jresult;
26381 }
26382
26383
26384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26385   int jresult ;
26386   int result;
26387
26388   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26389   jresult = (int)result;
26390   return jresult;
26391 }
26392
26393
26394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26395   int jresult ;
26396   int result;
26397
26398   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26399   jresult = (int)result;
26400   return jresult;
26401 }
26402
26403
26404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26405   int jresult ;
26406   int result;
26407
26408   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26409   jresult = (int)result;
26410   return jresult;
26411 }
26412
26413
26414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26415   int jresult ;
26416   int result;
26417
26418   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26419   jresult = (int)result;
26420   return jresult;
26421 }
26422
26423
26424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26425   int jresult ;
26426   int result;
26427
26428   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26429   jresult = (int)result;
26430   return jresult;
26431 }
26432
26433
26434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26435   int jresult ;
26436   int result;
26437
26438   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26439   jresult = (int)result;
26440   return jresult;
26441 }
26442
26443
26444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26445   int jresult ;
26446   int result;
26447
26448   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26449   jresult = (int)result;
26450   return jresult;
26451 }
26452
26453
26454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26455   int jresult ;
26456   int result;
26457
26458   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26459   jresult = (int)result;
26460   return jresult;
26461 }
26462
26463
26464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26465   int jresult ;
26466   int result;
26467
26468   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26469   jresult = (int)result;
26470   return jresult;
26471 }
26472
26473
26474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26475   int jresult ;
26476   int result;
26477
26478   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26479   jresult = (int)result;
26480   return jresult;
26481 }
26482
26483
26484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26485   int jresult ;
26486   int result;
26487
26488   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26489   jresult = (int)result;
26490   return jresult;
26491 }
26492
26493
26494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26495   int jresult ;
26496   int result;
26497
26498   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26499   jresult = (int)result;
26500   return jresult;
26501 }
26502
26503
26504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26505   int jresult ;
26506   int result;
26507
26508   result = (int)Dali::Renderer::Property::RENDER_MODE;
26509   jresult = (int)result;
26510   return jresult;
26511 }
26512
26513
26514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26515   int jresult ;
26516   int result;
26517
26518   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26519   jresult = (int)result;
26520   return jresult;
26521 }
26522
26523
26524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26525   int jresult ;
26526   int result;
26527
26528   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26529   jresult = (int)result;
26530   return jresult;
26531 }
26532
26533
26534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26535   int jresult ;
26536   int result;
26537
26538   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26539   jresult = (int)result;
26540   return jresult;
26541 }
26542
26543
26544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26545   int jresult ;
26546   int result;
26547
26548   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26549   jresult = (int)result;
26550   return jresult;
26551 }
26552
26553
26554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26555   int jresult ;
26556   int result;
26557
26558   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26559   jresult = (int)result;
26560   return jresult;
26561 }
26562
26563
26564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26565   int jresult ;
26566   int result;
26567
26568   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26569   jresult = (int)result;
26570   return jresult;
26571 }
26572
26573
26574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26575   int jresult ;
26576   int result;
26577
26578   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26579   jresult = (int)result;
26580   return jresult;
26581 }
26582
26583
26584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26585   void * jresult ;
26586   Dali::Renderer::Property *result = 0 ;
26587
26588   {
26589     try {
26590       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26591     } catch (std::out_of_range& e) {
26592       {
26593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26594       };
26595     } catch (std::exception& e) {
26596       {
26597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26598       };
26599     } catch (Dali::DaliException e) {
26600       {
26601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26602       };
26603     } catch (...) {
26604       {
26605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26606       };
26607     }
26608   }
26609
26610   jresult = (void *)result;
26611   return jresult;
26612 }
26613
26614
26615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26616   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26617
26618   arg1 = (Dali::Renderer::Property *)jarg1;
26619   {
26620     try {
26621       delete arg1;
26622     } catch (std::out_of_range& e) {
26623       {
26624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26625       };
26626     } catch (std::exception& e) {
26627       {
26628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26629       };
26630     } catch (Dali::DaliException e) {
26631       {
26632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26633       };
26634     } catch (...) {
26635       {
26636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26637       };
26638     }
26639   }
26640
26641 }
26642
26643
26644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26645   void * jresult ;
26646   Dali::Geometry *arg1 = 0 ;
26647   Dali::Shader *arg2 = 0 ;
26648   Dali::Renderer result;
26649
26650   arg1 = (Dali::Geometry *)jarg1;
26651   if (!arg1) {
26652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26653     return 0;
26654   }
26655   arg2 = (Dali::Shader *)jarg2;
26656   if (!arg2) {
26657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26658     return 0;
26659   }
26660   {
26661     try {
26662       result = Dali::Renderer::New(*arg1,*arg2);
26663     } catch (std::out_of_range& e) {
26664       {
26665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26666       };
26667     } catch (std::exception& e) {
26668       {
26669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26670       };
26671     } catch (Dali::DaliException e) {
26672       {
26673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26674       };
26675     } catch (...) {
26676       {
26677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26678       };
26679     }
26680   }
26681
26682   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26683   return jresult;
26684 }
26685
26686
26687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26688   void * jresult ;
26689   Dali::Renderer *result = 0 ;
26690
26691   {
26692     try {
26693       result = (Dali::Renderer *)new Dali::Renderer();
26694     } catch (std::out_of_range& e) {
26695       {
26696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26697       };
26698     } catch (std::exception& e) {
26699       {
26700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26701       };
26702     } catch (Dali::DaliException e) {
26703       {
26704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26705       };
26706     } catch (...) {
26707       {
26708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26709       };
26710     }
26711   }
26712
26713   jresult = (void *)result;
26714   return jresult;
26715 }
26716
26717
26718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26719   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26720
26721   arg1 = (Dali::Renderer *)jarg1;
26722   {
26723     try {
26724       delete arg1;
26725     } catch (std::out_of_range& e) {
26726       {
26727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26728       };
26729     } catch (std::exception& e) {
26730       {
26731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26732       };
26733     } catch (Dali::DaliException e) {
26734       {
26735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26736       };
26737     } catch (...) {
26738       {
26739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26740       };
26741     }
26742   }
26743
26744 }
26745
26746
26747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26748   void * jresult ;
26749   Dali::Renderer *arg1 = 0 ;
26750   Dali::Renderer *result = 0 ;
26751
26752   arg1 = (Dali::Renderer *)jarg1;
26753   if (!arg1) {
26754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26755     return 0;
26756   }
26757   {
26758     try {
26759       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26760     } catch (std::out_of_range& e) {
26761       {
26762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26763       };
26764     } catch (std::exception& e) {
26765       {
26766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26767       };
26768     } catch (Dali::DaliException e) {
26769       {
26770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26771       };
26772     } catch (...) {
26773       {
26774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26775       };
26776     }
26777   }
26778
26779   jresult = (void *)result;
26780   return jresult;
26781 }
26782
26783
26784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26785   void * jresult ;
26786   Dali::BaseHandle arg1 ;
26787   Dali::BaseHandle *argp1 ;
26788   Dali::Renderer result;
26789
26790   argp1 = (Dali::BaseHandle *)jarg1;
26791   if (!argp1) {
26792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26793     return 0;
26794   }
26795   arg1 = *argp1;
26796   {
26797     try {
26798       result = Dali::Renderer::DownCast(arg1);
26799     } catch (std::out_of_range& e) {
26800       {
26801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26802       };
26803     } catch (std::exception& e) {
26804       {
26805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26806       };
26807     } catch (Dali::DaliException e) {
26808       {
26809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26810       };
26811     } catch (...) {
26812       {
26813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26814       };
26815     }
26816   }
26817
26818   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26819   return jresult;
26820 }
26821
26822
26823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
26824   void * jresult ;
26825   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26826   Dali::Renderer *arg2 = 0 ;
26827   Dali::Renderer *result = 0 ;
26828
26829   arg1 = (Dali::Renderer *)jarg1;
26830   arg2 = (Dali::Renderer *)jarg2;
26831   if (!arg2) {
26832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26833     return 0;
26834   }
26835   {
26836     try {
26837       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
26838     } catch (std::out_of_range& e) {
26839       {
26840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26841       };
26842     } catch (std::exception& e) {
26843       {
26844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26845       };
26846     } catch (Dali::DaliException e) {
26847       {
26848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26849       };
26850     } catch (...) {
26851       {
26852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26853       };
26854     }
26855   }
26856
26857   jresult = (void *)result;
26858   return jresult;
26859 }
26860
26861
26862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
26863   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26864   Dali::Geometry *arg2 = 0 ;
26865
26866   arg1 = (Dali::Renderer *)jarg1;
26867   arg2 = (Dali::Geometry *)jarg2;
26868   if (!arg2) {
26869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26870     return ;
26871   }
26872   {
26873     try {
26874       (arg1)->SetGeometry(*arg2);
26875     } catch (std::out_of_range& e) {
26876       {
26877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26878       };
26879     } catch (std::exception& e) {
26880       {
26881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26882       };
26883     } catch (Dali::DaliException e) {
26884       {
26885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26886       };
26887     } catch (...) {
26888       {
26889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26890       };
26891     }
26892   }
26893
26894 }
26895
26896
26897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
26898   void * jresult ;
26899   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26900   Dali::Geometry result;
26901
26902   arg1 = (Dali::Renderer *)jarg1;
26903   {
26904     try {
26905       result = ((Dali::Renderer const *)arg1)->GetGeometry();
26906     } catch (std::out_of_range& e) {
26907       {
26908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26909       };
26910     } catch (std::exception& e) {
26911       {
26912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26913       };
26914     } catch (Dali::DaliException e) {
26915       {
26916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26917       };
26918     } catch (...) {
26919       {
26920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26921       };
26922     }
26923   }
26924
26925   jresult = new Dali::Geometry((const Dali::Geometry &)result);
26926   return jresult;
26927 }
26928
26929
26930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
26931   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26932   int arg2 ;
26933   int arg3 ;
26934
26935   arg1 = (Dali::Renderer *)jarg1;
26936   arg2 = (int)jarg2;
26937   arg3 = (int)jarg3;
26938   {
26939     try {
26940       (arg1)->SetIndexRange(arg2,arg3);
26941     } catch (std::out_of_range& e) {
26942       {
26943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26944       };
26945     } catch (std::exception& e) {
26946       {
26947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26948       };
26949     } catch (Dali::DaliException e) {
26950       {
26951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26952       };
26953     } catch (...) {
26954       {
26955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26956       };
26957     }
26958   }
26959
26960 }
26961
26962
26963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
26964   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26965   Dali::TextureSet *arg2 = 0 ;
26966
26967   arg1 = (Dali::Renderer *)jarg1;
26968   arg2 = (Dali::TextureSet *)jarg2;
26969   if (!arg2) {
26970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
26971     return ;
26972   }
26973   {
26974     try {
26975       (arg1)->SetTextures(*arg2);
26976     } catch (std::out_of_range& e) {
26977       {
26978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26979       };
26980     } catch (std::exception& e) {
26981       {
26982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26983       };
26984     } catch (Dali::DaliException e) {
26985       {
26986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26987       };
26988     } catch (...) {
26989       {
26990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26991       };
26992     }
26993   }
26994
26995 }
26996
26997
26998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
26999   void * jresult ;
27000   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27001   Dali::TextureSet result;
27002
27003   arg1 = (Dali::Renderer *)jarg1;
27004   {
27005     try {
27006       result = ((Dali::Renderer const *)arg1)->GetTextures();
27007     } catch (std::out_of_range& e) {
27008       {
27009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27010       };
27011     } catch (std::exception& e) {
27012       {
27013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27014       };
27015     } catch (Dali::DaliException e) {
27016       {
27017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27018       };
27019     } catch (...) {
27020       {
27021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27022       };
27023     }
27024   }
27025
27026   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27027   return jresult;
27028 }
27029
27030
27031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27032   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27033   Dali::Shader *arg2 = 0 ;
27034
27035   arg1 = (Dali::Renderer *)jarg1;
27036   arg2 = (Dali::Shader *)jarg2;
27037   if (!arg2) {
27038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27039     return ;
27040   }
27041   {
27042     try {
27043       (arg1)->SetShader(*arg2);
27044     } catch (std::out_of_range& e) {
27045       {
27046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27047       };
27048     } catch (std::exception& e) {
27049       {
27050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27051       };
27052     } catch (Dali::DaliException e) {
27053       {
27054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27055       };
27056     } catch (...) {
27057       {
27058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27059       };
27060     }
27061   }
27062
27063 }
27064
27065
27066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27067   void * jresult ;
27068   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27069   Dali::Shader result;
27070
27071   arg1 = (Dali::Renderer *)jarg1;
27072   {
27073     try {
27074       result = ((Dali::Renderer const *)arg1)->GetShader();
27075     } catch (std::out_of_range& e) {
27076       {
27077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27078       };
27079     } catch (std::exception& e) {
27080       {
27081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27082       };
27083     } catch (Dali::DaliException e) {
27084       {
27085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27086       };
27087     } catch (...) {
27088       {
27089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27090       };
27091     }
27092   }
27093
27094   jresult = new Dali::Shader((const Dali::Shader &)result);
27095   return jresult;
27096 }
27097
27098
27099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27100   void * jresult ;
27101   Dali::FrameBuffer::Attachment *result = 0 ;
27102
27103   {
27104     try {
27105       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27106     } catch (std::out_of_range& e) {
27107       {
27108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27109       };
27110     } catch (std::exception& e) {
27111       {
27112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27113       };
27114     } catch (Dali::DaliException e) {
27115       {
27116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27117       };
27118     } catch (...) {
27119       {
27120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27121       };
27122     }
27123   }
27124
27125   jresult = (void *)result;
27126   return jresult;
27127 }
27128
27129
27130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27131   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27132
27133   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27134   {
27135     try {
27136       delete arg1;
27137     } catch (std::out_of_range& e) {
27138       {
27139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27140       };
27141     } catch (std::exception& e) {
27142       {
27143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27144       };
27145     } catch (Dali::DaliException e) {
27146       {
27147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27148       };
27149     } catch (...) {
27150       {
27151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27152       };
27153     }
27154   }
27155
27156 }
27157
27158
27159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27160   void * jresult ;
27161   unsigned int arg1 ;
27162   unsigned int arg2 ;
27163   unsigned int arg3 ;
27164   Dali::FrameBuffer result;
27165
27166   arg1 = (unsigned int)jarg1;
27167   arg2 = (unsigned int)jarg2;
27168   arg3 = (unsigned int)jarg3;
27169   {
27170     try {
27171       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
27172     } catch (std::out_of_range& e) {
27173       {
27174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27175       };
27176     } catch (std::exception& e) {
27177       {
27178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27179       };
27180     } catch (Dali::DaliException e) {
27181       {
27182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27183       };
27184     } catch (...) {
27185       {
27186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27187       };
27188     }
27189   }
27190
27191   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27192   return jresult;
27193 }
27194
27195
27196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27197   void * jresult ;
27198   Dali::FrameBuffer *result = 0 ;
27199
27200   {
27201     try {
27202       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27203     } catch (std::out_of_range& e) {
27204       {
27205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27206       };
27207     } catch (std::exception& e) {
27208       {
27209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27210       };
27211     } catch (Dali::DaliException e) {
27212       {
27213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27214       };
27215     } catch (...) {
27216       {
27217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27218       };
27219     }
27220   }
27221
27222   jresult = (void *)result;
27223   return jresult;
27224 }
27225
27226
27227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27228   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27229
27230   arg1 = (Dali::FrameBuffer *)jarg1;
27231   {
27232     try {
27233       delete arg1;
27234     } catch (std::out_of_range& e) {
27235       {
27236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27237       };
27238     } catch (std::exception& e) {
27239       {
27240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27241       };
27242     } catch (Dali::DaliException e) {
27243       {
27244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27245       };
27246     } catch (...) {
27247       {
27248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27249       };
27250     }
27251   }
27252
27253 }
27254
27255
27256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27257   void * jresult ;
27258   Dali::FrameBuffer *arg1 = 0 ;
27259   Dali::FrameBuffer *result = 0 ;
27260
27261   arg1 = (Dali::FrameBuffer *)jarg1;
27262   if (!arg1) {
27263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27264     return 0;
27265   }
27266   {
27267     try {
27268       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27269     } catch (std::out_of_range& e) {
27270       {
27271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27272       };
27273     } catch (std::exception& e) {
27274       {
27275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27276       };
27277     } catch (Dali::DaliException e) {
27278       {
27279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27280       };
27281     } catch (...) {
27282       {
27283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27284       };
27285     }
27286   }
27287
27288   jresult = (void *)result;
27289   return jresult;
27290 }
27291
27292
27293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27294   void * jresult ;
27295   Dali::BaseHandle arg1 ;
27296   Dali::BaseHandle *argp1 ;
27297   Dali::FrameBuffer result;
27298
27299   argp1 = (Dali::BaseHandle *)jarg1;
27300   if (!argp1) {
27301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27302     return 0;
27303   }
27304   arg1 = *argp1;
27305   {
27306     try {
27307       result = Dali::FrameBuffer::DownCast(arg1);
27308     } catch (std::out_of_range& e) {
27309       {
27310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27311       };
27312     } catch (std::exception& e) {
27313       {
27314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27315       };
27316     } catch (Dali::DaliException e) {
27317       {
27318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27319       };
27320     } catch (...) {
27321       {
27322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27323       };
27324     }
27325   }
27326
27327   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27328   return jresult;
27329 }
27330
27331
27332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27333   void * jresult ;
27334   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27335   Dali::FrameBuffer *arg2 = 0 ;
27336   Dali::FrameBuffer *result = 0 ;
27337
27338   arg1 = (Dali::FrameBuffer *)jarg1;
27339   arg2 = (Dali::FrameBuffer *)jarg2;
27340   if (!arg2) {
27341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27342     return 0;
27343   }
27344   {
27345     try {
27346       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27347     } catch (std::out_of_range& e) {
27348       {
27349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27350       };
27351     } catch (std::exception& e) {
27352       {
27353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27354       };
27355     } catch (Dali::DaliException e) {
27356       {
27357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27358       };
27359     } catch (...) {
27360       {
27361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27362       };
27363     }
27364   }
27365
27366   jresult = (void *)result;
27367   return jresult;
27368 }
27369
27370
27371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27372   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27373   Dali::Texture *arg2 = 0 ;
27374
27375   arg1 = (Dali::FrameBuffer *)jarg1;
27376   arg2 = (Dali::Texture *)jarg2;
27377   if (!arg2) {
27378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27379     return ;
27380   }
27381   {
27382     try {
27383       (arg1)->AttachColorTexture(*arg2);
27384     } catch (std::out_of_range& e) {
27385       {
27386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27387       };
27388     } catch (std::exception& e) {
27389       {
27390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27391       };
27392     } catch (Dali::DaliException e) {
27393       {
27394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27395       };
27396     } catch (...) {
27397       {
27398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27399       };
27400     }
27401   }
27402
27403 }
27404
27405
27406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27407   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27408   Dali::Texture *arg2 = 0 ;
27409   unsigned int arg3 ;
27410   unsigned int arg4 ;
27411
27412   arg1 = (Dali::FrameBuffer *)jarg1;
27413   arg2 = (Dali::Texture *)jarg2;
27414   if (!arg2) {
27415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27416     return ;
27417   }
27418   arg3 = (unsigned int)jarg3;
27419   arg4 = (unsigned int)jarg4;
27420   {
27421     try {
27422       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27423     } catch (std::out_of_range& e) {
27424       {
27425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27426       };
27427     } catch (std::exception& e) {
27428       {
27429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27430       };
27431     } catch (Dali::DaliException e) {
27432       {
27433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27434       };
27435     } catch (...) {
27436       {
27437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27438       };
27439     }
27440   }
27441
27442 }
27443
27444
27445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27446   void * jresult ;
27447   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27448   Dali::Texture result;
27449
27450   arg1 = (Dali::FrameBuffer *)jarg1;
27451   {
27452     try {
27453       result = (arg1)->GetColorTexture();
27454     } catch (std::out_of_range& e) {
27455       {
27456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27457       };
27458     } catch (std::exception& e) {
27459       {
27460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27461       };
27462     } catch (Dali::DaliException e) {
27463       {
27464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27465       };
27466     } catch (...) {
27467       {
27468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27469       };
27470     }
27471   }
27472
27473   jresult = new Dali::Texture((const Dali::Texture &)result);
27474   return jresult;
27475 }
27476
27477
27478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27479   void * jresult ;
27480   Dali::RenderTaskList *result = 0 ;
27481
27482   {
27483     try {
27484       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27485     } catch (std::out_of_range& e) {
27486       {
27487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27488       };
27489     } catch (std::exception& e) {
27490       {
27491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27492       };
27493     } catch (Dali::DaliException e) {
27494       {
27495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27496       };
27497     } catch (...) {
27498       {
27499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27500       };
27501     }
27502   }
27503
27504   jresult = (void *)result;
27505   return jresult;
27506 }
27507
27508
27509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27510   void * jresult ;
27511   Dali::BaseHandle arg1 ;
27512   Dali::BaseHandle *argp1 ;
27513   Dali::RenderTaskList result;
27514
27515   argp1 = (Dali::BaseHandle *)jarg1;
27516   if (!argp1) {
27517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27518     return 0;
27519   }
27520   arg1 = *argp1;
27521   {
27522     try {
27523       result = Dali::RenderTaskList::DownCast(arg1);
27524     } catch (std::out_of_range& e) {
27525       {
27526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27527       };
27528     } catch (std::exception& e) {
27529       {
27530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27531       };
27532     } catch (Dali::DaliException e) {
27533       {
27534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27535       };
27536     } catch (...) {
27537       {
27538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27539       };
27540     }
27541   }
27542
27543   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27544   return jresult;
27545 }
27546
27547
27548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27549   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27550
27551   arg1 = (Dali::RenderTaskList *)jarg1;
27552   {
27553     try {
27554       delete arg1;
27555     } catch (std::out_of_range& e) {
27556       {
27557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27558       };
27559     } catch (std::exception& e) {
27560       {
27561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27562       };
27563     } catch (Dali::DaliException e) {
27564       {
27565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27566       };
27567     } catch (...) {
27568       {
27569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27570       };
27571     }
27572   }
27573
27574 }
27575
27576
27577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27578   void * jresult ;
27579   Dali::RenderTaskList *arg1 = 0 ;
27580   Dali::RenderTaskList *result = 0 ;
27581
27582   arg1 = (Dali::RenderTaskList *)jarg1;
27583   if (!arg1) {
27584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27585     return 0;
27586   }
27587   {
27588     try {
27589       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27590     } catch (std::out_of_range& e) {
27591       {
27592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27593       };
27594     } catch (std::exception& e) {
27595       {
27596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27597       };
27598     } catch (Dali::DaliException e) {
27599       {
27600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27601       };
27602     } catch (...) {
27603       {
27604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27605       };
27606     }
27607   }
27608
27609   jresult = (void *)result;
27610   return jresult;
27611 }
27612
27613
27614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27615   void * jresult ;
27616   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27617   Dali::RenderTaskList *arg2 = 0 ;
27618   Dali::RenderTaskList *result = 0 ;
27619
27620   arg1 = (Dali::RenderTaskList *)jarg1;
27621   arg2 = (Dali::RenderTaskList *)jarg2;
27622   if (!arg2) {
27623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27624     return 0;
27625   }
27626   {
27627     try {
27628       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27629     } catch (std::out_of_range& e) {
27630       {
27631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27632       };
27633     } catch (std::exception& e) {
27634       {
27635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27636       };
27637     } catch (Dali::DaliException e) {
27638       {
27639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27640       };
27641     } catch (...) {
27642       {
27643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27644       };
27645     }
27646   }
27647
27648   jresult = (void *)result;
27649   return jresult;
27650 }
27651
27652
27653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27654   void * jresult ;
27655   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27656   Dali::RenderTask result;
27657
27658   arg1 = (Dali::RenderTaskList *)jarg1;
27659   {
27660     try {
27661       result = (arg1)->CreateTask();
27662     } catch (std::out_of_range& e) {
27663       {
27664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27665       };
27666     } catch (std::exception& e) {
27667       {
27668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27669       };
27670     } catch (Dali::DaliException e) {
27671       {
27672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27673       };
27674     } catch (...) {
27675       {
27676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27677       };
27678     }
27679   }
27680
27681   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27682   return jresult;
27683 }
27684
27685
27686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27687   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27688   Dali::RenderTask arg2 ;
27689   Dali::RenderTask *argp2 ;
27690
27691   arg1 = (Dali::RenderTaskList *)jarg1;
27692   argp2 = (Dali::RenderTask *)jarg2;
27693   if (!argp2) {
27694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27695     return ;
27696   }
27697   arg2 = *argp2;
27698   {
27699     try {
27700       (arg1)->RemoveTask(arg2);
27701     } catch (std::out_of_range& e) {
27702       {
27703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27704       };
27705     } catch (std::exception& e) {
27706       {
27707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27708       };
27709     } catch (Dali::DaliException e) {
27710       {
27711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27712       };
27713     } catch (...) {
27714       {
27715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27716       };
27717     }
27718   }
27719
27720 }
27721
27722
27723 //// ===============================================end part 1 =================
27724
27725 //// ========================= part 2 ===============================
27726
27727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27728   unsigned int jresult ;
27729   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27730   unsigned int result;
27731
27732   arg1 = (Dali::RenderTaskList *)jarg1;
27733   {
27734     try {
27735       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27736     } catch (std::out_of_range& e) {
27737       {
27738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27739       };
27740     } catch (std::exception& e) {
27741       {
27742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27743       };
27744     } catch (Dali::DaliException e) {
27745       {
27746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27747       };
27748     } catch (...) {
27749       {
27750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27751       };
27752     }
27753   }
27754
27755   jresult = result;
27756   return jresult;
27757 }
27758
27759
27760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27761   void * jresult ;
27762   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27763   unsigned int arg2 ;
27764   Dali::RenderTask result;
27765
27766   arg1 = (Dali::RenderTaskList *)jarg1;
27767   arg2 = (unsigned int)jarg2;
27768   {
27769     try {
27770       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27771     } catch (std::out_of_range& e) {
27772       {
27773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27774       };
27775     } catch (std::exception& e) {
27776       {
27777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27778       };
27779     } catch (Dali::DaliException e) {
27780       {
27781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27782       };
27783     } catch (...) {
27784       {
27785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27786       };
27787     }
27788   }
27789
27790   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27791   return jresult;
27792 }
27793
27794
27795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27796   int jresult ;
27797   int result;
27798
27799   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27800   jresult = (int)result;
27801   return jresult;
27802 }
27803
27804
27805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27806   int jresult ;
27807   int result;
27808
27809   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27810   jresult = (int)result;
27811   return jresult;
27812 }
27813
27814
27815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27816   int jresult ;
27817   int result;
27818
27819   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
27820   jresult = (int)result;
27821   return jresult;
27822 }
27823
27824
27825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
27826   int jresult ;
27827   int result;
27828
27829   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
27830   jresult = (int)result;
27831   return jresult;
27832 }
27833
27834
27835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
27836   void * jresult ;
27837   Dali::RenderTask::Property *result = 0 ;
27838
27839   {
27840     try {
27841       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
27842     } catch (std::out_of_range& e) {
27843       {
27844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27845       };
27846     } catch (std::exception& e) {
27847       {
27848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27849       };
27850     } catch (Dali::DaliException e) {
27851       {
27852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27853       };
27854     } catch (...) {
27855       {
27856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27857       };
27858     }
27859   }
27860
27861   jresult = (void *)result;
27862   return jresult;
27863 }
27864
27865
27866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
27867   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
27868
27869   arg1 = (Dali::RenderTask::Property *)jarg1;
27870   {
27871     try {
27872       delete arg1;
27873     } catch (std::out_of_range& e) {
27874       {
27875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27876       };
27877     } catch (std::exception& e) {
27878       {
27879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27880       };
27881     } catch (Dali::DaliException e) {
27882       {
27883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27884       };
27885     } catch (...) {
27886       {
27887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27888       };
27889     }
27890   }
27891
27892 }
27893
27894
27895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
27896   void * jresult ;
27897   bool (*result)(Dali::Vector2 &) = 0 ;
27898
27899   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
27900   jresult = (void *)result;
27901   return jresult;
27902 }
27903
27904
27905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
27906   void * jresult ;
27907   bool (*result)(Dali::Vector2 &) = 0 ;
27908
27909   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
27910   jresult = (void *)result;
27911   return jresult;
27912 }
27913
27914
27915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
27916   unsigned int jresult ;
27917   bool result;
27918
27919   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
27920   jresult = result;
27921   return jresult;
27922 }
27923
27924
27925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
27926   unsigned int jresult ;
27927   bool result;
27928
27929   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
27930   jresult = result;
27931   return jresult;
27932 }
27933
27934
27935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
27936   void * jresult ;
27937   Dali::Vector4 *result = 0 ;
27938
27939   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
27940   jresult = (void *)result;
27941   return jresult;
27942 }
27943
27944
27945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
27946   unsigned int jresult ;
27947   bool result;
27948
27949   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
27950   jresult = result;
27951   return jresult;
27952 }
27953
27954
27955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
27956   unsigned int jresult ;
27957   bool result;
27958
27959   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
27960   jresult = result;
27961   return jresult;
27962 }
27963
27964
27965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
27966   unsigned int jresult ;
27967   unsigned int result;
27968
27969   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
27970   jresult = result;
27971   return jresult;
27972 }
27973
27974
27975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
27976   void * jresult ;
27977   Dali::RenderTask *result = 0 ;
27978
27979   {
27980     try {
27981       result = (Dali::RenderTask *)new Dali::RenderTask();
27982     } catch (std::out_of_range& e) {
27983       {
27984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27985       };
27986     } catch (std::exception& e) {
27987       {
27988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27989       };
27990     } catch (Dali::DaliException e) {
27991       {
27992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27993       };
27994     } catch (...) {
27995       {
27996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27997       };
27998     }
27999   }
28000
28001   jresult = (void *)result;
28002   return jresult;
28003 }
28004
28005
28006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28007   void * jresult ;
28008   Dali::BaseHandle arg1 ;
28009   Dali::BaseHandle *argp1 ;
28010   Dali::RenderTask result;
28011
28012   argp1 = (Dali::BaseHandle *)jarg1;
28013   if (!argp1) {
28014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28015     return 0;
28016   }
28017   arg1 = *argp1;
28018   {
28019     try {
28020       result = Dali::RenderTask::DownCast(arg1);
28021     } catch (std::out_of_range& e) {
28022       {
28023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28024       };
28025     } catch (std::exception& e) {
28026       {
28027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28028       };
28029     } catch (Dali::DaliException e) {
28030       {
28031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28032       };
28033     } catch (...) {
28034       {
28035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28036       };
28037     }
28038   }
28039
28040   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28041   return jresult;
28042 }
28043
28044
28045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28046   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28047
28048   arg1 = (Dali::RenderTask *)jarg1;
28049   {
28050     try {
28051       delete arg1;
28052     } catch (std::out_of_range& e) {
28053       {
28054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28055       };
28056     } catch (std::exception& e) {
28057       {
28058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28059       };
28060     } catch (Dali::DaliException e) {
28061       {
28062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28063       };
28064     } catch (...) {
28065       {
28066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28067       };
28068     }
28069   }
28070
28071 }
28072
28073
28074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28075   void * jresult ;
28076   Dali::RenderTask *arg1 = 0 ;
28077   Dali::RenderTask *result = 0 ;
28078
28079   arg1 = (Dali::RenderTask *)jarg1;
28080   if (!arg1) {
28081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28082     return 0;
28083   }
28084   {
28085     try {
28086       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28087     } catch (std::out_of_range& e) {
28088       {
28089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28090       };
28091     } catch (std::exception& e) {
28092       {
28093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28094       };
28095     } catch (Dali::DaliException e) {
28096       {
28097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28098       };
28099     } catch (...) {
28100       {
28101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28102       };
28103     }
28104   }
28105
28106   jresult = (void *)result;
28107   return jresult;
28108 }
28109
28110
28111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28112   void * jresult ;
28113   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28114   Dali::RenderTask *arg2 = 0 ;
28115   Dali::RenderTask *result = 0 ;
28116
28117   arg1 = (Dali::RenderTask *)jarg1;
28118   arg2 = (Dali::RenderTask *)jarg2;
28119   if (!arg2) {
28120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28121     return 0;
28122   }
28123   {
28124     try {
28125       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28126     } catch (std::out_of_range& e) {
28127       {
28128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28129       };
28130     } catch (std::exception& e) {
28131       {
28132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28133       };
28134     } catch (Dali::DaliException e) {
28135       {
28136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28137       };
28138     } catch (...) {
28139       {
28140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28141       };
28142     }
28143   }
28144
28145   jresult = (void *)result;
28146   return jresult;
28147 }
28148
28149
28150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28151   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28152   Dali::Actor arg2 ;
28153   Dali::Actor *argp2 ;
28154
28155   arg1 = (Dali::RenderTask *)jarg1;
28156   argp2 = (Dali::Actor *)jarg2;
28157   if (!argp2) {
28158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28159     return ;
28160   }
28161   arg2 = *argp2;
28162   {
28163     try {
28164       (arg1)->SetSourceActor(arg2);
28165     } catch (std::out_of_range& e) {
28166       {
28167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28168       };
28169     } catch (std::exception& e) {
28170       {
28171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28172       };
28173     } catch (Dali::DaliException e) {
28174       {
28175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28176       };
28177     } catch (...) {
28178       {
28179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28180       };
28181     }
28182   }
28183
28184 }
28185
28186
28187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28188   void * jresult ;
28189   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28190   Dali::Actor result;
28191
28192   arg1 = (Dali::RenderTask *)jarg1;
28193   {
28194     try {
28195       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28196     } catch (std::out_of_range& e) {
28197       {
28198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28199       };
28200     } catch (std::exception& e) {
28201       {
28202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28203       };
28204     } catch (Dali::DaliException e) {
28205       {
28206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28207       };
28208     } catch (...) {
28209       {
28210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28211       };
28212     }
28213   }
28214
28215   jresult = new Dali::Actor((const Dali::Actor &)result);
28216   return jresult;
28217 }
28218
28219
28220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28221   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28222   bool arg2 ;
28223
28224   arg1 = (Dali::RenderTask *)jarg1;
28225   arg2 = jarg2 ? true : false;
28226   {
28227     try {
28228       (arg1)->SetExclusive(arg2);
28229     } catch (std::out_of_range& e) {
28230       {
28231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28232       };
28233     } catch (std::exception& e) {
28234       {
28235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28236       };
28237     } catch (Dali::DaliException e) {
28238       {
28239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28240       };
28241     } catch (...) {
28242       {
28243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28244       };
28245     }
28246   }
28247
28248 }
28249
28250
28251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28252   unsigned int jresult ;
28253   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28254   bool result;
28255
28256   arg1 = (Dali::RenderTask *)jarg1;
28257   {
28258     try {
28259       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28260     } catch (std::out_of_range& e) {
28261       {
28262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28263       };
28264     } catch (std::exception& e) {
28265       {
28266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28267       };
28268     } catch (Dali::DaliException e) {
28269       {
28270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28271       };
28272     } catch (...) {
28273       {
28274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28275       };
28276     }
28277   }
28278
28279   jresult = result;
28280   return jresult;
28281 }
28282
28283
28284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28285   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28286   bool arg2 ;
28287
28288   arg1 = (Dali::RenderTask *)jarg1;
28289   arg2 = jarg2 ? true : false;
28290   {
28291     try {
28292       (arg1)->SetInputEnabled(arg2);
28293     } catch (std::out_of_range& e) {
28294       {
28295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28296       };
28297     } catch (std::exception& e) {
28298       {
28299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28300       };
28301     } catch (Dali::DaliException e) {
28302       {
28303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28304       };
28305     } catch (...) {
28306       {
28307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28308       };
28309     }
28310   }
28311
28312 }
28313
28314
28315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28316   unsigned int jresult ;
28317   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28318   bool result;
28319
28320   arg1 = (Dali::RenderTask *)jarg1;
28321   {
28322     try {
28323       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28324     } catch (std::out_of_range& e) {
28325       {
28326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28327       };
28328     } catch (std::exception& e) {
28329       {
28330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28331       };
28332     } catch (Dali::DaliException e) {
28333       {
28334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28335       };
28336     } catch (...) {
28337       {
28338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28339       };
28340     }
28341   }
28342
28343   jresult = result;
28344   return jresult;
28345 }
28346
28347
28348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28349   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28350   Dali::CameraActor arg2 ;
28351   Dali::CameraActor *argp2 ;
28352
28353   arg1 = (Dali::RenderTask *)jarg1;
28354   argp2 = (Dali::CameraActor *)jarg2;
28355   if (!argp2) {
28356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28357     return ;
28358   }
28359   arg2 = *argp2;
28360   {
28361     try {
28362       (arg1)->SetCameraActor(arg2);
28363     } catch (std::out_of_range& e) {
28364       {
28365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28366       };
28367     } catch (std::exception& e) {
28368       {
28369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28370       };
28371     } catch (Dali::DaliException e) {
28372       {
28373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28374       };
28375     } catch (...) {
28376       {
28377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28378       };
28379     }
28380   }
28381
28382 }
28383
28384
28385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28386   void * jresult ;
28387   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28388   Dali::CameraActor result;
28389
28390   arg1 = (Dali::RenderTask *)jarg1;
28391   {
28392     try {
28393       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28394     } catch (std::out_of_range& e) {
28395       {
28396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28397       };
28398     } catch (std::exception& e) {
28399       {
28400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28401       };
28402     } catch (Dali::DaliException e) {
28403       {
28404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28405       };
28406     } catch (...) {
28407       {
28408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28409       };
28410     }
28411   }
28412
28413   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28414   return jresult;
28415 }
28416
28417
28418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28419   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28420   Dali::FrameBuffer arg2 ;
28421   Dali::FrameBuffer *argp2 ;
28422
28423   arg1 = (Dali::RenderTask *)jarg1;
28424   argp2 = (Dali::FrameBuffer *)jarg2;
28425   if (!argp2) {
28426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28427     return ;
28428   }
28429   arg2 = *argp2;
28430   {
28431     try {
28432       (arg1)->SetFrameBuffer(arg2);
28433     } catch (std::out_of_range& e) {
28434       {
28435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28436       };
28437     } catch (std::exception& e) {
28438       {
28439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28440       };
28441     } catch (Dali::DaliException e) {
28442       {
28443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28444       };
28445     } catch (...) {
28446       {
28447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28448       };
28449     }
28450   }
28451
28452 }
28453
28454
28455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28456   void * jresult ;
28457   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28458   Dali::FrameBuffer result;
28459
28460   arg1 = (Dali::RenderTask *)jarg1;
28461   {
28462     try {
28463       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28464     } catch (std::out_of_range& e) {
28465       {
28466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28467       };
28468     } catch (std::exception& e) {
28469       {
28470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28471       };
28472     } catch (Dali::DaliException e) {
28473       {
28474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28475       };
28476     } catch (...) {
28477       {
28478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28479       };
28480     }
28481   }
28482
28483   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28484   return jresult;
28485 }
28486
28487
28488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28489   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28490   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28491
28492   arg1 = (Dali::RenderTask *)jarg1;
28493   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28494   {
28495     try {
28496       (arg1)->SetScreenToFrameBufferFunction(arg2);
28497     } catch (std::out_of_range& e) {
28498       {
28499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28500       };
28501     } catch (std::exception& e) {
28502       {
28503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28504       };
28505     } catch (Dali::DaliException e) {
28506       {
28507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28508       };
28509     } catch (...) {
28510       {
28511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28512       };
28513     }
28514   }
28515
28516 }
28517
28518
28519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28520   void * jresult ;
28521   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28522   Dali::RenderTask::ScreenToFrameBufferFunction result;
28523
28524   arg1 = (Dali::RenderTask *)jarg1;
28525   {
28526     try {
28527       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28528     } catch (std::out_of_range& e) {
28529       {
28530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28531       };
28532     } catch (std::exception& e) {
28533       {
28534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28535       };
28536     } catch (Dali::DaliException e) {
28537       {
28538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28539       };
28540     } catch (...) {
28541       {
28542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28543       };
28544     }
28545   }
28546
28547   jresult = (void *)result;
28548   return jresult;
28549 }
28550
28551
28552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28553   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28554   Dali::Actor arg2 ;
28555   Dali::Actor *argp2 ;
28556
28557   arg1 = (Dali::RenderTask *)jarg1;
28558   argp2 = (Dali::Actor *)jarg2;
28559   if (!argp2) {
28560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28561     return ;
28562   }
28563   arg2 = *argp2;
28564   {
28565     try {
28566       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28567     } catch (std::out_of_range& e) {
28568       {
28569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28570       };
28571     } catch (std::exception& e) {
28572       {
28573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28574       };
28575     } catch (Dali::DaliException e) {
28576       {
28577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28578       };
28579     } catch (...) {
28580       {
28581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28582       };
28583     }
28584   }
28585
28586 }
28587
28588
28589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28590   void * jresult ;
28591   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28592   Dali::Actor result;
28593
28594   arg1 = (Dali::RenderTask *)jarg1;
28595   {
28596     try {
28597       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28598     } catch (std::out_of_range& e) {
28599       {
28600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28601       };
28602     } catch (std::exception& e) {
28603       {
28604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28605       };
28606     } catch (Dali::DaliException e) {
28607       {
28608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28609       };
28610     } catch (...) {
28611       {
28612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28613       };
28614     }
28615   }
28616
28617   jresult = new Dali::Actor((const Dali::Actor &)result);
28618   return jresult;
28619 }
28620
28621
28622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28623   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28624   Dali::Vector2 arg2 ;
28625   Dali::Vector2 *argp2 ;
28626
28627   arg1 = (Dali::RenderTask *)jarg1;
28628   argp2 = (Dali::Vector2 *)jarg2;
28629   if (!argp2) {
28630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28631     return ;
28632   }
28633   arg2 = *argp2;
28634   {
28635     try {
28636       (arg1)->SetViewportPosition(arg2);
28637     } catch (std::out_of_range& e) {
28638       {
28639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28640       };
28641     } catch (std::exception& e) {
28642       {
28643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28644       };
28645     } catch (Dali::DaliException e) {
28646       {
28647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28648       };
28649     } catch (...) {
28650       {
28651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28652       };
28653     }
28654   }
28655
28656 }
28657
28658
28659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28660   void * jresult ;
28661   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28662   Dali::Vector2 result;
28663
28664   arg1 = (Dali::RenderTask *)jarg1;
28665   {
28666     try {
28667       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28668     } catch (std::out_of_range& e) {
28669       {
28670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28671       };
28672     } catch (std::exception& e) {
28673       {
28674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28675       };
28676     } catch (Dali::DaliException e) {
28677       {
28678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28679       };
28680     } catch (...) {
28681       {
28682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28683       };
28684     }
28685   }
28686
28687   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28688   return jresult;
28689 }
28690
28691
28692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28693   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28694   Dali::Vector2 arg2 ;
28695   Dali::Vector2 *argp2 ;
28696
28697   arg1 = (Dali::RenderTask *)jarg1;
28698   argp2 = (Dali::Vector2 *)jarg2;
28699   if (!argp2) {
28700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28701     return ;
28702   }
28703   arg2 = *argp2;
28704   {
28705     try {
28706       (arg1)->SetViewportSize(arg2);
28707     } catch (std::out_of_range& e) {
28708       {
28709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28710       };
28711     } catch (std::exception& e) {
28712       {
28713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28714       };
28715     } catch (Dali::DaliException e) {
28716       {
28717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28718       };
28719     } catch (...) {
28720       {
28721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28722       };
28723     }
28724   }
28725
28726 }
28727
28728
28729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28730   void * jresult ;
28731   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28732   Dali::Vector2 result;
28733
28734   arg1 = (Dali::RenderTask *)jarg1;
28735   {
28736     try {
28737       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28738     } catch (std::out_of_range& e) {
28739       {
28740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28741       };
28742     } catch (std::exception& e) {
28743       {
28744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28745       };
28746     } catch (Dali::DaliException e) {
28747       {
28748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28749       };
28750     } catch (...) {
28751       {
28752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28753       };
28754     }
28755   }
28756
28757   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28758   return jresult;
28759 }
28760
28761
28762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
28763   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28764   Dali::Viewport arg2 ;
28765   Dali::Viewport *argp2 ;
28766
28767   arg1 = (Dali::RenderTask *)jarg1;
28768   argp2 = (Dali::Viewport *)jarg2;
28769   if (!argp2) {
28770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
28771     return ;
28772   }
28773   arg2 = *argp2;
28774   {
28775     try {
28776       (arg1)->SetViewport(arg2);
28777     } catch (std::out_of_range& e) {
28778       {
28779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28780       };
28781     } catch (std::exception& e) {
28782       {
28783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28784       };
28785     } catch (Dali::DaliException e) {
28786       {
28787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28788       };
28789     } catch (...) {
28790       {
28791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28792       };
28793     }
28794   }
28795
28796 }
28797
28798
28799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
28800   void * jresult ;
28801   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28802   Dali::Viewport result;
28803
28804   arg1 = (Dali::RenderTask *)jarg1;
28805   {
28806     try {
28807       result = ((Dali::RenderTask const *)arg1)->GetViewport();
28808     } catch (std::out_of_range& e) {
28809       {
28810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28811       };
28812     } catch (std::exception& e) {
28813       {
28814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28815       };
28816     } catch (Dali::DaliException e) {
28817       {
28818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28819       };
28820     } catch (...) {
28821       {
28822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28823       };
28824     }
28825   }
28826
28827   jresult = new Dali::Viewport((const Dali::Viewport &)result);
28828   return jresult;
28829 }
28830
28831
28832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
28833   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28834   Dali::Vector4 *arg2 = 0 ;
28835
28836   arg1 = (Dali::RenderTask *)jarg1;
28837   arg2 = (Dali::Vector4 *)jarg2;
28838   if (!arg2) {
28839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
28840     return ;
28841   }
28842   {
28843     try {
28844       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
28845     } catch (std::out_of_range& e) {
28846       {
28847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28848       };
28849     } catch (std::exception& e) {
28850       {
28851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28852       };
28853     } catch (Dali::DaliException e) {
28854       {
28855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28856       };
28857     } catch (...) {
28858       {
28859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28860       };
28861     }
28862   }
28863
28864 }
28865
28866
28867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
28868   void * jresult ;
28869   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28870   Dali::Vector4 result;
28871
28872   arg1 = (Dali::RenderTask *)jarg1;
28873   {
28874     try {
28875       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
28876     } catch (std::out_of_range& e) {
28877       {
28878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28879       };
28880     } catch (std::exception& e) {
28881       {
28882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28883       };
28884     } catch (Dali::DaliException e) {
28885       {
28886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28887       };
28888     } catch (...) {
28889       {
28890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28891       };
28892     }
28893   }
28894
28895   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
28896   return jresult;
28897 }
28898
28899
28900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
28901   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28902   bool arg2 ;
28903
28904   arg1 = (Dali::RenderTask *)jarg1;
28905   arg2 = jarg2 ? true : false;
28906   {
28907     try {
28908       (arg1)->SetClearEnabled(arg2);
28909     } catch (std::out_of_range& e) {
28910       {
28911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28912       };
28913     } catch (std::exception& e) {
28914       {
28915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28916       };
28917     } catch (Dali::DaliException e) {
28918       {
28919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28920       };
28921     } catch (...) {
28922       {
28923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28924       };
28925     }
28926   }
28927
28928 }
28929
28930
28931 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
28932   unsigned int jresult ;
28933   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28934   bool result;
28935
28936   arg1 = (Dali::RenderTask *)jarg1;
28937   {
28938     try {
28939       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
28940     } catch (std::out_of_range& e) {
28941       {
28942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28943       };
28944     } catch (std::exception& e) {
28945       {
28946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28947       };
28948     } catch (Dali::DaliException e) {
28949       {
28950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28951       };
28952     } catch (...) {
28953       {
28954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28955       };
28956     }
28957   }
28958
28959   jresult = result;
28960   return jresult;
28961 }
28962
28963
28964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
28965   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28966   bool arg2 ;
28967
28968   arg1 = (Dali::RenderTask *)jarg1;
28969   arg2 = jarg2 ? true : false;
28970   {
28971     try {
28972       (arg1)->SetCullMode(arg2);
28973     } catch (std::out_of_range& e) {
28974       {
28975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28976       };
28977     } catch (std::exception& e) {
28978       {
28979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28980       };
28981     } catch (Dali::DaliException e) {
28982       {
28983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28984       };
28985     } catch (...) {
28986       {
28987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28988       };
28989     }
28990   }
28991
28992 }
28993
28994
28995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
28996   unsigned int jresult ;
28997   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28998   bool result;
28999
29000   arg1 = (Dali::RenderTask *)jarg1;
29001   {
29002     try {
29003       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29004     } catch (std::out_of_range& e) {
29005       {
29006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29007       };
29008     } catch (std::exception& e) {
29009       {
29010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29011       };
29012     } catch (Dali::DaliException e) {
29013       {
29014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29015       };
29016     } catch (...) {
29017       {
29018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29019       };
29020     }
29021   }
29022
29023   jresult = result;
29024   return jresult;
29025 }
29026
29027
29028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29029   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29030   unsigned int arg2 ;
29031
29032   arg1 = (Dali::RenderTask *)jarg1;
29033   arg2 = (unsigned int)jarg2;
29034   {
29035     try {
29036       (arg1)->SetRefreshRate(arg2);
29037     } catch (std::out_of_range& e) {
29038       {
29039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29040       };
29041     } catch (std::exception& e) {
29042       {
29043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29044       };
29045     } catch (Dali::DaliException e) {
29046       {
29047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29048       };
29049     } catch (...) {
29050       {
29051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29052       };
29053     }
29054   }
29055
29056 }
29057
29058
29059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29060   unsigned int jresult ;
29061   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29062   unsigned int result;
29063
29064   arg1 = (Dali::RenderTask *)jarg1;
29065   {
29066     try {
29067       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29068     } catch (std::out_of_range& e) {
29069       {
29070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29071       };
29072     } catch (std::exception& e) {
29073       {
29074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29075       };
29076     } catch (Dali::DaliException e) {
29077       {
29078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29079       };
29080     } catch (...) {
29081       {
29082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29083       };
29084     }
29085   }
29086
29087   jresult = result;
29088   return jresult;
29089 }
29090
29091
29092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29093   unsigned int jresult ;
29094   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29095   Dali::Vector3 *arg2 = 0 ;
29096   float *arg3 = 0 ;
29097   float *arg4 = 0 ;
29098   bool result;
29099
29100   arg1 = (Dali::RenderTask *)jarg1;
29101   arg2 = (Dali::Vector3 *)jarg2;
29102   if (!arg2) {
29103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29104     return 0;
29105   }
29106   arg3 = (float *)jarg3;
29107   arg4 = (float *)jarg4;
29108   {
29109     try {
29110       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29111     } catch (std::out_of_range& e) {
29112       {
29113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29114       };
29115     } catch (std::exception& e) {
29116       {
29117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29118       };
29119     } catch (Dali::DaliException e) {
29120       {
29121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29122       };
29123     } catch (...) {
29124       {
29125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29126       };
29127     }
29128   }
29129
29130   jresult = result;
29131   return jresult;
29132 }
29133
29134
29135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29136   unsigned int jresult ;
29137   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29138   Dali::Actor arg2 ;
29139   float arg3 ;
29140   float arg4 ;
29141   float *arg5 = 0 ;
29142   float *arg6 = 0 ;
29143   Dali::Actor *argp2 ;
29144   bool result;
29145
29146   arg1 = (Dali::RenderTask *)jarg1;
29147   argp2 = (Dali::Actor *)jarg2;
29148   if (!argp2) {
29149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29150     return 0;
29151   }
29152   arg2 = *argp2;
29153   arg3 = (float)jarg3;
29154   arg4 = (float)jarg4;
29155   arg5 = (float *)jarg5;
29156   arg6 = (float *)jarg6;
29157   {
29158     try {
29159       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29160     } catch (std::out_of_range& e) {
29161       {
29162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29163       };
29164     } catch (std::exception& e) {
29165       {
29166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29167       };
29168     } catch (Dali::DaliException e) {
29169       {
29170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29171       };
29172     } catch (...) {
29173       {
29174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29175       };
29176     }
29177   }
29178
29179   jresult = result;
29180   return jresult;
29181 }
29182
29183
29184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29185   void * jresult ;
29186   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29187   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29188
29189   arg1 = (Dali::RenderTask *)jarg1;
29190   {
29191     try {
29192       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29193     } catch (std::out_of_range& e) {
29194       {
29195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29196       };
29197     } catch (std::exception& e) {
29198       {
29199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29200       };
29201     } catch (Dali::DaliException e) {
29202       {
29203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29204       };
29205     } catch (...) {
29206       {
29207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29208       };
29209     }
29210   }
29211
29212   jresult = (void *)result;
29213   return jresult;
29214 }
29215
29216
29217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29218   void * jresult ;
29219   int arg1 ;
29220   Dali::TouchPoint::State arg2 ;
29221   float arg3 ;
29222   float arg4 ;
29223   Dali::TouchPoint *result = 0 ;
29224
29225   arg1 = (int)jarg1;
29226   arg2 = (Dali::TouchPoint::State)jarg2;
29227   arg3 = (float)jarg3;
29228   arg4 = (float)jarg4;
29229   {
29230     try {
29231       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29232     } catch (std::out_of_range& e) {
29233       {
29234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29235       };
29236     } catch (std::exception& e) {
29237       {
29238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29239       };
29240     } catch (Dali::DaliException e) {
29241       {
29242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29243       };
29244     } catch (...) {
29245       {
29246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29247       };
29248     }
29249   }
29250
29251   jresult = (void *)result;
29252   return jresult;
29253 }
29254
29255
29256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29257   void * jresult ;
29258   int arg1 ;
29259   Dali::TouchPoint::State arg2 ;
29260   float arg3 ;
29261   float arg4 ;
29262   float arg5 ;
29263   float arg6 ;
29264   Dali::TouchPoint *result = 0 ;
29265
29266   arg1 = (int)jarg1;
29267   arg2 = (Dali::TouchPoint::State)jarg2;
29268   arg3 = (float)jarg3;
29269   arg4 = (float)jarg4;
29270   arg5 = (float)jarg5;
29271   arg6 = (float)jarg6;
29272   {
29273     try {
29274       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29275     } catch (std::out_of_range& e) {
29276       {
29277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29278       };
29279     } catch (std::exception& e) {
29280       {
29281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29282       };
29283     } catch (Dali::DaliException e) {
29284       {
29285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29286       };
29287     } catch (...) {
29288       {
29289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29290       };
29291     }
29292   }
29293
29294   jresult = (void *)result;
29295   return jresult;
29296 }
29297
29298
29299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29300   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29301
29302   arg1 = (Dali::TouchPoint *)jarg1;
29303   {
29304     try {
29305       delete arg1;
29306     } catch (std::out_of_range& e) {
29307       {
29308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29309       };
29310     } catch (std::exception& e) {
29311       {
29312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29313       };
29314     } catch (Dali::DaliException e) {
29315       {
29316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29317       };
29318     } catch (...) {
29319       {
29320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29321       };
29322     }
29323   }
29324
29325 }
29326
29327
29328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29329   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29330   int arg2 ;
29331
29332   arg1 = (Dali::TouchPoint *)jarg1;
29333   arg2 = (int)jarg2;
29334   if (arg1) (arg1)->deviceId = arg2;
29335 }
29336
29337
29338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29339   int jresult ;
29340   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29341   int result;
29342
29343   arg1 = (Dali::TouchPoint *)jarg1;
29344   result = (int) ((arg1)->deviceId);
29345   jresult = result;
29346   return jresult;
29347 }
29348
29349
29350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29351   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29352   Dali::TouchPoint::State arg2 ;
29353
29354   arg1 = (Dali::TouchPoint *)jarg1;
29355   arg2 = (Dali::TouchPoint::State)jarg2;
29356   if (arg1) (arg1)->state = arg2;
29357 }
29358
29359
29360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29361   int jresult ;
29362   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29363   Dali::TouchPoint::State result;
29364
29365   arg1 = (Dali::TouchPoint *)jarg1;
29366   result = (Dali::TouchPoint::State) ((arg1)->state);
29367   jresult = (int)result;
29368   return jresult;
29369 }
29370
29371
29372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29373   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29374   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29375
29376   arg1 = (Dali::TouchPoint *)jarg1;
29377   arg2 = (Dali::Actor *)jarg2;
29378   if (arg1) (arg1)->hitActor = *arg2;
29379 }
29380
29381
29382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29383   void * jresult ;
29384   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29385   Dali::Actor *result = 0 ;
29386
29387   arg1 = (Dali::TouchPoint *)jarg1;
29388   result = (Dali::Actor *)& ((arg1)->hitActor);
29389   jresult = (void *)result;
29390   return jresult;
29391 }
29392
29393
29394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29395   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29396   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29397
29398   arg1 = (Dali::TouchPoint *)jarg1;
29399   arg2 = (Dali::Vector2 *)jarg2;
29400   if (arg1) (arg1)->local = *arg2;
29401 }
29402
29403
29404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29405   void * jresult ;
29406   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29407   Dali::Vector2 *result = 0 ;
29408
29409   arg1 = (Dali::TouchPoint *)jarg1;
29410   result = (Dali::Vector2 *)& ((arg1)->local);
29411   jresult = (void *)result;
29412   return jresult;
29413 }
29414
29415
29416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29417   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29418   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29419
29420   arg1 = (Dali::TouchPoint *)jarg1;
29421   arg2 = (Dali::Vector2 *)jarg2;
29422   if (arg1) (arg1)->screen = *arg2;
29423 }
29424
29425
29426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29427   void * jresult ;
29428   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29429   Dali::Vector2 *result = 0 ;
29430
29431   arg1 = (Dali::TouchPoint *)jarg1;
29432   result = (Dali::Vector2 *)& ((arg1)->screen);
29433   jresult = (void *)result;
29434   return jresult;
29435 }
29436
29437
29438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29439   void * jresult ;
29440   Dali::TouchEvent *result = 0 ;
29441
29442   {
29443     try {
29444       result = (Dali::TouchEvent *)new Dali::TouchEvent();
29445     } catch (std::out_of_range& e) {
29446       {
29447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29448       };
29449     } catch (std::exception& e) {
29450       {
29451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29452       };
29453     } catch (Dali::DaliException e) {
29454       {
29455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29456       };
29457     } catch (...) {
29458       {
29459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29460       };
29461     }
29462   }
29463
29464   jresult = (void *)result;
29465   return jresult;
29466 }
29467
29468
29469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29470   void * jresult ;
29471   Dali::TouchEvent *arg1 = 0 ;
29472   Dali::TouchEvent *result = 0 ;
29473
29474   arg1 = (Dali::TouchEvent *)jarg1;
29475   if (!arg1) {
29476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
29477     return 0;
29478   }
29479   {
29480     try {
29481       result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1);
29482     } catch (std::out_of_range& e) {
29483       {
29484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29485       };
29486     } catch (std::exception& e) {
29487       {
29488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29489       };
29490     } catch (Dali::DaliException e) {
29491       {
29492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29493       };
29494     } catch (...) {
29495       {
29496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29497       };
29498     }
29499   }
29500
29501   jresult = (void *)result;
29502   return jresult;
29503 }
29504
29505
29506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29507   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29508
29509   arg1 = (Dali::TouchEvent *)jarg1;
29510   {
29511     try {
29512       delete arg1;
29513     } catch (std::out_of_range& e) {
29514       {
29515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29516       };
29517     } catch (std::exception& e) {
29518       {
29519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29520       };
29521     } catch (Dali::DaliException e) {
29522       {
29523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29524       };
29525     } catch (...) {
29526       {
29527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29528       };
29529     }
29530   }
29531
29532 }
29533
29534
29535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29536   void * jresult ;
29537   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29538   Dali::TouchEvent *arg2 = 0 ;
29539   Dali::TouchEvent *result = 0 ;
29540
29541   arg1 = (Dali::TouchEvent *)jarg1;
29542   arg2 = (Dali::TouchEvent *)jarg2;
29543   if (!arg2) {
29544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
29545     return 0;
29546   }
29547   {
29548     try {
29549       result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2);
29550     } catch (std::out_of_range& e) {
29551       {
29552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29553       };
29554     } catch (std::exception& e) {
29555       {
29556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29557       };
29558     } catch (Dali::DaliException e) {
29559       {
29560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29561       };
29562     } catch (...) {
29563       {
29564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29565       };
29566     }
29567   }
29568
29569   jresult = (void *)result;
29570   return jresult;
29571 }
29572
29573
29574 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29575   unsigned long jresult ;
29576   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29577   unsigned long result;
29578
29579   arg1 = (Dali::TouchEvent *)jarg1;
29580   {
29581     try {
29582       result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime();
29583     } catch (std::out_of_range& e) {
29584       {
29585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29586       };
29587     } catch (std::exception& e) {
29588       {
29589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29590       };
29591     } catch (Dali::DaliException e) {
29592       {
29593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29594       };
29595     } catch (...) {
29596       {
29597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29598       };
29599     }
29600   }
29601
29602   jresult = (unsigned long)result;
29603   return jresult;
29604 }
29605
29606
29607 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29608   unsigned long jresult ;
29609   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29610   std::size_t result;
29611
29612   arg1 = (Dali::TouchEvent *)jarg1;
29613   {
29614     try {
29615       result = ((Dali::TouchEvent const *)arg1)->GetPointCount();
29616     } catch (std::out_of_range& e) {
29617       {
29618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29619       };
29620     } catch (std::exception& e) {
29621       {
29622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29623       };
29624     } catch (Dali::DaliException e) {
29625       {
29626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29627       };
29628     } catch (...) {
29629       {
29630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29631       };
29632     }
29633   }
29634
29635   jresult = (unsigned long)result;
29636   return jresult;
29637 }
29638
29639
29640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29641   int jresult ;
29642   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29643   std::size_t arg2 ;
29644   int32_t result;
29645
29646   arg1 = (Dali::TouchEvent *)jarg1;
29647   arg2 = (std::size_t)jarg2;
29648   {
29649     try {
29650       result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2);
29651     } catch (std::out_of_range& e) {
29652       {
29653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29654       };
29655     } catch (std::exception& e) {
29656       {
29657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29658       };
29659     } catch (Dali::DaliException e) {
29660       {
29661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29662       };
29663     } catch (...) {
29664       {
29665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29666       };
29667     }
29668   }
29669
29670   jresult = result;
29671   return jresult;
29672 }
29673
29674
29675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29676   int jresult ;
29677   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29678   std::size_t arg2 ;
29679   Dali::PointState::Type result;
29680
29681   arg1 = (Dali::TouchEvent *)jarg1;
29682   arg2 = (std::size_t)jarg2;
29683   {
29684     try {
29685       result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2);
29686     } catch (std::out_of_range& e) {
29687       {
29688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29689       };
29690     } catch (std::exception& e) {
29691       {
29692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29693       };
29694     } catch (Dali::DaliException e) {
29695       {
29696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29697       };
29698     } catch (...) {
29699       {
29700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29701       };
29702     }
29703   }
29704
29705   jresult = (int)result;
29706   return jresult;
29707 }
29708
29709
29710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29711   void * jresult ;
29712   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29713   std::size_t arg2 ;
29714   Dali::Actor result;
29715
29716   arg1 = (Dali::TouchEvent *)jarg1;
29717   arg2 = (std::size_t)jarg2;
29718   {
29719     try {
29720       result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2);
29721     } catch (std::out_of_range& e) {
29722       {
29723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29724       };
29725     } catch (std::exception& e) {
29726       {
29727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29728       };
29729     } catch (Dali::DaliException e) {
29730       {
29731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29732       };
29733     } catch (...) {
29734       {
29735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29736       };
29737     }
29738   }
29739
29740   jresult = new Dali::Actor((const Dali::Actor &)result);
29741   return jresult;
29742 }
29743
29744
29745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29746   void * jresult ;
29747   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29748   std::size_t arg2 ;
29749   Dali::Vector2 *result = 0 ;
29750
29751   arg1 = (Dali::TouchEvent *)jarg1;
29752   arg2 = (std::size_t)jarg2;
29753   {
29754     try {
29755       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2);
29756     } catch (std::out_of_range& e) {
29757       {
29758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29759       };
29760     } catch (std::exception& e) {
29761       {
29762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29763       };
29764     } catch (Dali::DaliException e) {
29765       {
29766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29767       };
29768     } catch (...) {
29769       {
29770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29771       };
29772     }
29773   }
29774
29775   jresult = (void *)result;
29776   return jresult;
29777 }
29778
29779
29780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
29781   void * jresult ;
29782   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29783   std::size_t arg2 ;
29784   Dali::Vector2 *result = 0 ;
29785
29786   arg1 = (Dali::TouchEvent *)jarg1;
29787   arg2 = (std::size_t)jarg2;
29788   {
29789     try {
29790       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2);
29791     } catch (std::out_of_range& e) {
29792       {
29793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29794       };
29795     } catch (std::exception& e) {
29796       {
29797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29798       };
29799     } catch (Dali::DaliException e) {
29800       {
29801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29802       };
29803     } catch (...) {
29804       {
29805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29806       };
29807     }
29808   }
29809
29810   jresult = (void *)result;
29811   return jresult;
29812 }
29813
29814
29815 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
29816   float jresult ;
29817   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29818   std::size_t arg2 ;
29819   float result;
29820
29821   arg1 = (Dali::TouchEvent *)jarg1;
29822   arg2 = (std::size_t)jarg2;
29823   {
29824     try {
29825       result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2);
29826     } catch (std::out_of_range& e) {
29827       {
29828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29829       };
29830     } catch (std::exception& e) {
29831       {
29832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29833       };
29834     } catch (Dali::DaliException e) {
29835       {
29836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29837       };
29838     } catch (...) {
29839       {
29840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29841       };
29842     }
29843   }
29844
29845   jresult = result;
29846   return jresult;
29847 }
29848
29849
29850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
29851   void * jresult ;
29852   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29853   std::size_t arg2 ;
29854   Dali::Vector2 *result = 0 ;
29855
29856   arg1 = (Dali::TouchEvent *)jarg1;
29857   arg2 = (std::size_t)jarg2;
29858   {
29859     try {
29860       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2);
29861     } catch (std::out_of_range& e) {
29862       {
29863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29864       };
29865     } catch (std::exception& e) {
29866       {
29867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29868       };
29869     } catch (Dali::DaliException e) {
29870       {
29871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29872       };
29873     } catch (...) {
29874       {
29875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29876       };
29877     }
29878   }
29879
29880   jresult = (void *)result;
29881   return jresult;
29882 }
29883
29884
29885 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
29886   float jresult ;
29887   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29888   std::size_t arg2 ;
29889   float result;
29890
29891   arg1 = (Dali::TouchEvent *)jarg1;
29892   arg2 = (std::size_t)jarg2;
29893   {
29894     try {
29895       result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2);
29896     } catch (std::out_of_range& e) {
29897       {
29898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29899       };
29900     } catch (std::exception& e) {
29901       {
29902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29903       };
29904     } catch (Dali::DaliException e) {
29905       {
29906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29907       };
29908     } catch (...) {
29909       {
29910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29911       };
29912     }
29913   }
29914
29915   jresult = result;
29916   return jresult;
29917 }
29918
29919
29920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
29921   void * jresult ;
29922   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29923   std::size_t arg2 ;
29924   Dali::Degree result;
29925
29926   arg1 = (Dali::TouchEvent *)jarg1;
29927   arg2 = (std::size_t)jarg2;
29928   {
29929     try {
29930       result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2);
29931     } catch (std::out_of_range& e) {
29932       {
29933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29934       };
29935     } catch (std::exception& e) {
29936       {
29937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29938       };
29939     } catch (Dali::DaliException e) {
29940       {
29941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29942       };
29943     } catch (...) {
29944       {
29945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29946       };
29947     }
29948   }
29949
29950   jresult = new Dali::Degree((const Dali::Degree &)result);
29951   return jresult;
29952 }
29953
29954
29955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
29956   int jresult ;
29957   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29958   std::size_t arg2 ;
29959   Dali::MouseButton::Type result;
29960
29961   arg1 = (Dali::TouchEvent *)jarg1;
29962   arg2 = (std::size_t)jarg2;
29963   {
29964     try {
29965       result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2);
29966     } catch (std::out_of_range& e) {
29967       {
29968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29969       };
29970     } catch (std::exception& e) {
29971       {
29972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29973       };
29974     } catch (Dali::DaliException e) {
29975       {
29976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29977       };
29978     } catch (...) {
29979       {
29980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29981       };
29982     }
29983   }
29984
29985   jresult = static_cast< int >(result);
29986   return jresult;
29987 }
29988
29989
29990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
29991   void * jresult ;
29992   Dali::GestureDetector *result = 0 ;
29993
29994   {
29995     try {
29996       result = (Dali::GestureDetector *)new Dali::GestureDetector();
29997     } catch (std::out_of_range& e) {
29998       {
29999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30000       };
30001     } catch (std::exception& e) {
30002       {
30003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30004       };
30005     } catch (Dali::DaliException e) {
30006       {
30007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30008       };
30009     } catch (...) {
30010       {
30011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30012       };
30013     }
30014   }
30015
30016   jresult = (void *)result;
30017   return jresult;
30018 }
30019
30020
30021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30022   void * jresult ;
30023   Dali::BaseHandle arg1 ;
30024   Dali::BaseHandle *argp1 ;
30025   Dali::GestureDetector result;
30026
30027   argp1 = (Dali::BaseHandle *)jarg1;
30028   if (!argp1) {
30029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30030     return 0;
30031   }
30032   arg1 = *argp1;
30033   {
30034     try {
30035       result = Dali::GestureDetector::DownCast(arg1);
30036     } catch (std::out_of_range& e) {
30037       {
30038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30039       };
30040     } catch (std::exception& e) {
30041       {
30042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30043       };
30044     } catch (Dali::DaliException e) {
30045       {
30046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30047       };
30048     } catch (...) {
30049       {
30050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30051       };
30052     }
30053   }
30054
30055   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30056   return jresult;
30057 }
30058
30059
30060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30061   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30062
30063   arg1 = (Dali::GestureDetector *)jarg1;
30064   {
30065     try {
30066       delete arg1;
30067     } catch (std::out_of_range& e) {
30068       {
30069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30070       };
30071     } catch (std::exception& e) {
30072       {
30073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30074       };
30075     } catch (Dali::DaliException e) {
30076       {
30077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30078       };
30079     } catch (...) {
30080       {
30081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30082       };
30083     }
30084   }
30085
30086 }
30087
30088
30089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30090   void * jresult ;
30091   Dali::GestureDetector *arg1 = 0 ;
30092   Dali::GestureDetector *result = 0 ;
30093
30094   arg1 = (Dali::GestureDetector *)jarg1;
30095   if (!arg1) {
30096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30097     return 0;
30098   }
30099   {
30100     try {
30101       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30102     } catch (std::out_of_range& e) {
30103       {
30104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30105       };
30106     } catch (std::exception& e) {
30107       {
30108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30109       };
30110     } catch (Dali::DaliException e) {
30111       {
30112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30113       };
30114     } catch (...) {
30115       {
30116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30117       };
30118     }
30119   }
30120
30121   jresult = (void *)result;
30122   return jresult;
30123 }
30124
30125
30126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30127   void * jresult ;
30128   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30129   Dali::GestureDetector *arg2 = 0 ;
30130   Dali::GestureDetector *result = 0 ;
30131
30132   arg1 = (Dali::GestureDetector *)jarg1;
30133   arg2 = (Dali::GestureDetector *)jarg2;
30134   if (!arg2) {
30135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30136     return 0;
30137   }
30138   {
30139     try {
30140       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30141     } catch (std::out_of_range& e) {
30142       {
30143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30144       };
30145     } catch (std::exception& e) {
30146       {
30147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30148       };
30149     } catch (Dali::DaliException e) {
30150       {
30151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30152       };
30153     } catch (...) {
30154       {
30155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30156       };
30157     }
30158   }
30159
30160   jresult = (void *)result;
30161   return jresult;
30162 }
30163
30164
30165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30166   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30167   Dali::Actor arg2 ;
30168   Dali::Actor *argp2 ;
30169
30170   arg1 = (Dali::GestureDetector *)jarg1;
30171   argp2 = (Dali::Actor *)jarg2;
30172   if (!argp2) {
30173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30174     return ;
30175   }
30176   arg2 = *argp2;
30177   {
30178     try {
30179       (arg1)->Attach(arg2);
30180     } catch (std::out_of_range& e) {
30181       {
30182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30183       };
30184     } catch (std::exception& e) {
30185       {
30186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30187       };
30188     } catch (Dali::DaliException e) {
30189       {
30190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30191       };
30192     } catch (...) {
30193       {
30194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30195       };
30196     }
30197   }
30198
30199 }
30200
30201
30202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30203   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30204   Dali::Actor arg2 ;
30205   Dali::Actor *argp2 ;
30206
30207   arg1 = (Dali::GestureDetector *)jarg1;
30208   argp2 = (Dali::Actor *)jarg2;
30209   if (!argp2) {
30210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30211     return ;
30212   }
30213   arg2 = *argp2;
30214   {
30215     try {
30216       (arg1)->Detach(arg2);
30217     } catch (std::out_of_range& e) {
30218       {
30219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30220       };
30221     } catch (std::exception& e) {
30222       {
30223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30224       };
30225     } catch (Dali::DaliException e) {
30226       {
30227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30228       };
30229     } catch (...) {
30230       {
30231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30232       };
30233     }
30234   }
30235
30236 }
30237
30238
30239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30240   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30241
30242   arg1 = (Dali::GestureDetector *)jarg1;
30243   {
30244     try {
30245       (arg1)->DetachAll();
30246     } catch (std::out_of_range& e) {
30247       {
30248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30249       };
30250     } catch (std::exception& e) {
30251       {
30252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30253       };
30254     } catch (Dali::DaliException e) {
30255       {
30256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30257       };
30258     } catch (...) {
30259       {
30260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30261       };
30262     }
30263   }
30264
30265 }
30266
30267
30268 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30269   unsigned long jresult ;
30270   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30271   size_t result;
30272
30273   arg1 = (Dali::GestureDetector *)jarg1;
30274   {
30275     try {
30276       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30277     } catch (std::out_of_range& e) {
30278       {
30279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30280       };
30281     } catch (std::exception& e) {
30282       {
30283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30284       };
30285     } catch (Dali::DaliException e) {
30286       {
30287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30288       };
30289     } catch (...) {
30290       {
30291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30292       };
30293     }
30294   }
30295
30296   jresult = (unsigned long)result;
30297   return jresult;
30298 }
30299
30300
30301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30302   void * jresult ;
30303   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30304   size_t arg2 ;
30305   Dali::Actor result;
30306
30307   arg1 = (Dali::GestureDetector *)jarg1;
30308   arg2 = (size_t)jarg2;
30309   {
30310     try {
30311       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30312     } catch (std::out_of_range& e) {
30313       {
30314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30315       };
30316     } catch (std::exception& e) {
30317       {
30318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30319       };
30320     } catch (Dali::DaliException e) {
30321       {
30322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30323       };
30324     } catch (...) {
30325       {
30326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30327       };
30328     }
30329   }
30330
30331   jresult = new Dali::Actor((const Dali::Actor &)result);
30332   return jresult;
30333 }
30334
30335
30336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30337   void * jresult ;
30338   Dali::Gesture *arg1 = 0 ;
30339   Dali::Gesture *result = 0 ;
30340
30341   arg1 = (Dali::Gesture *)jarg1;
30342   if (!arg1) {
30343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30344     return 0;
30345   }
30346   {
30347     try {
30348       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30349     } catch (std::out_of_range& e) {
30350       {
30351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30352       };
30353     } catch (std::exception& e) {
30354       {
30355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30356       };
30357     } catch (Dali::DaliException e) {
30358       {
30359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30360       };
30361     } catch (...) {
30362       {
30363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30364       };
30365     }
30366   }
30367
30368   jresult = (void *)result;
30369   return jresult;
30370 }
30371
30372
30373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30374   void * jresult ;
30375   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30376   Dali::Gesture *arg2 = 0 ;
30377   Dali::Gesture *result = 0 ;
30378
30379   arg1 = (Dali::Gesture *)jarg1;
30380   arg2 = (Dali::Gesture *)jarg2;
30381   if (!arg2) {
30382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30383     return 0;
30384   }
30385   {
30386     try {
30387       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30388     } catch (std::out_of_range& e) {
30389       {
30390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30391       };
30392     } catch (std::exception& e) {
30393       {
30394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30395       };
30396     } catch (Dali::DaliException e) {
30397       {
30398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30399       };
30400     } catch (...) {
30401       {
30402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30403       };
30404     }
30405   }
30406
30407   jresult = (void *)result;
30408   return jresult;
30409 }
30410
30411
30412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30413   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30414
30415   arg1 = (Dali::Gesture *)jarg1;
30416   {
30417     try {
30418       delete arg1;
30419     } catch (std::out_of_range& e) {
30420       {
30421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30422       };
30423     } catch (std::exception& e) {
30424       {
30425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30426       };
30427     } catch (Dali::DaliException e) {
30428       {
30429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30430       };
30431     } catch (...) {
30432       {
30433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30434       };
30435     }
30436   }
30437
30438 }
30439
30440
30441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30442   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30443   Dali::Gesture::Type arg2 ;
30444
30445   arg1 = (Dali::Gesture *)jarg1;
30446   arg2 = (Dali::Gesture::Type)jarg2;
30447   if (arg1) (arg1)->type = arg2;
30448 }
30449
30450
30451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30452   int jresult ;
30453   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30454   Dali::Gesture::Type result;
30455
30456   arg1 = (Dali::Gesture *)jarg1;
30457   result = (Dali::Gesture::Type) ((arg1)->type);
30458   jresult = (int)result;
30459   return jresult;
30460 }
30461
30462
30463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30464   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30465   Dali::Gesture::State arg2 ;
30466
30467   arg1 = (Dali::Gesture *)jarg1;
30468   arg2 = (Dali::Gesture::State)jarg2;
30469   if (arg1) (arg1)->state = arg2;
30470 }
30471
30472
30473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30474   int jresult ;
30475   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30476   Dali::Gesture::State result;
30477
30478   arg1 = (Dali::Gesture *)jarg1;
30479   result = (Dali::Gesture::State) ((arg1)->state);
30480   jresult = (int)result;
30481   return jresult;
30482 }
30483
30484
30485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30486   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30487   unsigned int arg2 ;
30488
30489   arg1 = (Dali::Gesture *)jarg1;
30490   arg2 = (unsigned int)jarg2;
30491   if (arg1) (arg1)->time = arg2;
30492 }
30493
30494
30495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30496   unsigned int jresult ;
30497   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30498   unsigned int result;
30499
30500   arg1 = (Dali::Gesture *)jarg1;
30501   result = (unsigned int) ((arg1)->time);
30502   jresult = result;
30503   return jresult;
30504 }
30505
30506
30507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30508   void * jresult ;
30509   Dali::HoverEvent *result = 0 ;
30510
30511   {
30512     try {
30513       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30514     } catch (std::out_of_range& e) {
30515       {
30516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30517       };
30518     } catch (std::exception& e) {
30519       {
30520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30521       };
30522     } catch (Dali::DaliException e) {
30523       {
30524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30525       };
30526     } catch (...) {
30527       {
30528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30529       };
30530     }
30531   }
30532
30533   jresult = (void *)result;
30534   return jresult;
30535 }
30536
30537
30538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) {
30539   void * jresult ;
30540   Dali::HoverEvent *arg1 = 0 ;
30541   Dali::HoverEvent *result = 0 ;
30542
30543   arg1 = (Dali::HoverEvent *)jarg1;
30544   if (!arg1) {
30545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
30546     return 0;
30547   }
30548   {
30549     try {
30550       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
30551     } catch (std::out_of_range& e) {
30552       {
30553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30554       };
30555     } catch (std::exception& e) {
30556       {
30557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30558       };
30559     } catch (Dali::DaliException e) {
30560       {
30561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30562       };
30563     } catch (...) {
30564       {
30565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30566       };
30567     }
30568   }
30569
30570   jresult = (void *)result;
30571   return jresult;
30572 }
30573
30574
30575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30576   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30577
30578   arg1 = (Dali::HoverEvent *)jarg1;
30579   {
30580     try {
30581       delete arg1;
30582     } catch (std::out_of_range& e) {
30583       {
30584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30585       };
30586     } catch (std::exception& e) {
30587       {
30588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30589       };
30590     } catch (Dali::DaliException e) {
30591       {
30592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30593       };
30594     } catch (...) {
30595       {
30596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30597       };
30598     }
30599   }
30600
30601 }
30602
30603
30604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) {
30605   void * jresult ;
30606   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30607   Dali::HoverEvent *arg2 = 0 ;
30608   Dali::HoverEvent *result = 0 ;
30609
30610   arg1 = (Dali::HoverEvent *)jarg1;
30611   arg2 = (Dali::HoverEvent *)jarg2;
30612   if (!arg2) {
30613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
30614     return 0;
30615   }
30616   {
30617     try {
30618       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
30619     } catch (std::out_of_range& e) {
30620       {
30621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30622       };
30623     } catch (std::exception& e) {
30624       {
30625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30626       };
30627     } catch (Dali::DaliException e) {
30628       {
30629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30630       };
30631     } catch (...) {
30632       {
30633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30634       };
30635     }
30636   }
30637
30638   jresult = (void *)result;
30639   return jresult;
30640 }
30641
30642
30643 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
30644   unsigned long jresult ;
30645   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30646   unsigned long result;
30647
30648   arg1 = (Dali::HoverEvent *)jarg1;
30649   {
30650     try {
30651       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
30652     } catch (std::out_of_range& e) {
30653       {
30654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30655       };
30656     } catch (std::exception& e) {
30657       {
30658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30659       };
30660     } catch (Dali::DaliException e) {
30661       {
30662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30663       };
30664     } catch (...) {
30665       {
30666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30667       };
30668     }
30669   }
30670
30671   jresult = (unsigned long)result;
30672   return jresult;
30673 }
30674
30675
30676 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30677   unsigned long jresult ;
30678   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30679   std::size_t result;
30680
30681   arg1 = (Dali::HoverEvent *)jarg1;
30682   {
30683     try {
30684       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
30685     } catch (std::out_of_range& e) {
30686       {
30687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30688       };
30689     } catch (std::exception& e) {
30690       {
30691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30692       };
30693     } catch (Dali::DaliException e) {
30694       {
30695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30696       };
30697     } catch (...) {
30698       {
30699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30700       };
30701     }
30702   }
30703
30704   jresult = (unsigned long)result;
30705   return jresult;
30706 }
30707
30708
30709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
30710   int jresult ;
30711   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30712   std::size_t arg2 ;
30713   int32_t result;
30714
30715   arg1 = (Dali::HoverEvent *)jarg1;
30716   arg2 = (std::size_t)jarg2;
30717   {
30718     try {
30719       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
30720     } catch (std::out_of_range& e) {
30721       {
30722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30723       };
30724     } catch (std::exception& e) {
30725       {
30726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30727       };
30728     } catch (Dali::DaliException e) {
30729       {
30730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30731       };
30732     } catch (...) {
30733       {
30734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30735       };
30736     }
30737   }
30738
30739   jresult = result;
30740   return jresult;
30741 }
30742
30743
30744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
30745   int jresult ;
30746   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30747   std::size_t arg2 ;
30748   Dali::PointState::Type result;
30749
30750   arg1 = (Dali::HoverEvent *)jarg1;
30751   arg2 = (std::size_t)jarg2;
30752   {
30753     try {
30754       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
30755     } catch (std::out_of_range& e) {
30756       {
30757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30758       };
30759     } catch (std::exception& e) {
30760       {
30761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30762       };
30763     } catch (Dali::DaliException e) {
30764       {
30765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30766       };
30767     } catch (...) {
30768       {
30769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30770       };
30771     }
30772   }
30773
30774   jresult = (int)result;
30775   return jresult;
30776 }
30777
30778
30779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
30780   void * jresult ;
30781   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30782   std::size_t arg2 ;
30783   Dali::Actor result;
30784
30785   arg1 = (Dali::HoverEvent *)jarg1;
30786   arg2 = (std::size_t)jarg2;
30787   {
30788     try {
30789       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
30790     } catch (std::out_of_range& e) {
30791       {
30792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30793       };
30794     } catch (std::exception& e) {
30795       {
30796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30797       };
30798     } catch (Dali::DaliException e) {
30799       {
30800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30801       };
30802     } catch (...) {
30803       {
30804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30805       };
30806     }
30807   }
30808
30809   jresult = new Dali::Actor((const Dali::Actor &)result);
30810   return jresult;
30811 }
30812
30813
30814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30815   void * jresult ;
30816   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30817   std::size_t arg2 ;
30818   Dali::Vector2 *result = 0 ;
30819
30820   arg1 = (Dali::HoverEvent *)jarg1;
30821   arg2 = (std::size_t)jarg2;
30822   {
30823     try {
30824       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
30825     } catch (std::out_of_range& e) {
30826       {
30827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30828       };
30829     } catch (std::exception& e) {
30830       {
30831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30832       };
30833     } catch (Dali::DaliException e) {
30834       {
30835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30836       };
30837     } catch (...) {
30838       {
30839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30840       };
30841     }
30842   }
30843
30844   jresult = (void *)result;
30845   return jresult;
30846 }
30847
30848
30849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30850   void * jresult ;
30851   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30852   std::size_t arg2 ;
30853   Dali::Vector2 *result = 0 ;
30854
30855   arg1 = (Dali::HoverEvent *)jarg1;
30856   arg2 = (std::size_t)jarg2;
30857   {
30858     try {
30859       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
30860     } catch (std::out_of_range& e) {
30861       {
30862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30863       };
30864     } catch (std::exception& e) {
30865       {
30866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30867       };
30868     } catch (Dali::DaliException e) {
30869       {
30870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30871       };
30872     } catch (...) {
30873       {
30874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30875       };
30876     }
30877   }
30878
30879   jresult = (void *)result;
30880   return jresult;
30881 }
30882
30883
30884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30885   void * jresult ;
30886   Dali::KeyEvent *result = 0 ;
30887
30888   {
30889     try {
30890       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30891     } catch (std::out_of_range& e) {
30892       {
30893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30894       };
30895     } catch (std::exception& e) {
30896       {
30897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30898       };
30899     } catch (Dali::DaliException e) {
30900       {
30901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30902       };
30903     } catch (...) {
30904       {
30905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30906       };
30907     }
30908   }
30909
30910   jresult = (void *)result;
30911   return jresult;
30912 }
30913
30914
30915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30916   void * jresult ;
30917   std::string *arg1 = 0 ;
30918   std::string *arg2 = 0 ;
30919   int arg3 ;
30920   int arg4 ;
30921   unsigned long arg5 ;
30922   Dali::KeyEvent::State *arg6 = 0 ;
30923   Dali::KeyEvent::State temp6 ;
30924   Dali::KeyEvent *result = 0 ;
30925
30926   if (!jarg1) {
30927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30928     return 0;
30929   }
30930   std::string arg1_str(jarg1);
30931   arg1 = &arg1_str;
30932   if (!jarg2) {
30933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30934     return 0;
30935   }
30936   std::string arg2_str(jarg2);
30937   arg2 = &arg2_str;
30938   arg3 = (int)jarg3;
30939   arg4 = (int)jarg4;
30940   arg5 = (unsigned long)jarg5;
30941   temp6 = (Dali::KeyEvent::State)jarg6;
30942   arg6 = &temp6;
30943   {
30944     try {
30945       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
30946     } catch (std::out_of_range& e) {
30947       {
30948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30949       };
30950     } catch (std::exception& e) {
30951       {
30952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30953       };
30954     } catch (Dali::DaliException e) {
30955       {
30956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30957       };
30958     } catch (...) {
30959       {
30960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30961       };
30962     }
30963   }
30964
30965   jresult = (void *)result;
30966
30967   //argout typemap for const std::string&
30968
30969
30970   //argout typemap for const std::string&
30971
30972   return jresult;
30973 }
30974
30975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
30976   void * jresult ;
30977   Dali::KeyEvent *arg1 = 0 ;
30978   Dali::KeyEvent *result = 0 ;
30979
30980   arg1 = (Dali::KeyEvent *)jarg1;
30981   if (!arg1) {
30982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30983     return 0;
30984   }
30985   {
30986     try {
30987       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
30988     } catch (std::out_of_range& e) {
30989       {
30990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30991       };
30992     } catch (std::exception& e) {
30993       {
30994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30995       };
30996     } catch (Dali::DaliException e) {
30997       {
30998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30999       };
31000     } catch (...) {
31001       {
31002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31003       };
31004     }
31005   }
31006
31007   jresult = (void *)result;
31008   return jresult;
31009 }
31010
31011
31012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31013   void * jresult ;
31014   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31015   Dali::KeyEvent *arg2 = 0 ;
31016   Dali::KeyEvent *result = 0 ;
31017
31018   arg1 = (Dali::KeyEvent *)jarg1;
31019   arg2 = (Dali::KeyEvent *)jarg2;
31020   if (!arg2) {
31021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31022     return 0;
31023   }
31024   {
31025     try {
31026       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31027     } catch (std::out_of_range& e) {
31028       {
31029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31030       };
31031     } catch (std::exception& e) {
31032       {
31033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31034       };
31035     } catch (Dali::DaliException e) {
31036       {
31037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31038       };
31039     } catch (...) {
31040       {
31041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31042       };
31043     }
31044   }
31045
31046   jresult = (void *)result;
31047   return jresult;
31048 }
31049
31050
31051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31052   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31053
31054   arg1 = (Dali::KeyEvent *)jarg1;
31055   {
31056     try {
31057       delete arg1;
31058     } catch (std::out_of_range& e) {
31059       {
31060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31061       };
31062     } catch (std::exception& e) {
31063       {
31064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31065       };
31066     } catch (Dali::DaliException e) {
31067       {
31068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31069       };
31070     } catch (...) {
31071       {
31072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31073       };
31074     }
31075   }
31076
31077 }
31078
31079
31080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31081   unsigned int jresult ;
31082   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31083   bool result;
31084
31085   arg1 = (Dali::KeyEvent *)jarg1;
31086   {
31087     try {
31088       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31089     } catch (std::out_of_range& e) {
31090       {
31091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31092       };
31093     } catch (std::exception& e) {
31094       {
31095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31096       };
31097     } catch (Dali::DaliException e) {
31098       {
31099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31100       };
31101     } catch (...) {
31102       {
31103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31104       };
31105     }
31106   }
31107
31108   jresult = result;
31109   return jresult;
31110 }
31111
31112
31113 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31114   unsigned int jresult ;
31115   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31116   bool result;
31117
31118   arg1 = (Dali::KeyEvent *)jarg1;
31119   {
31120     try {
31121       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31122     } catch (std::out_of_range& e) {
31123       {
31124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31125       };
31126     } catch (std::exception& e) {
31127       {
31128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31129       };
31130     } catch (Dali::DaliException e) {
31131       {
31132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31133       };
31134     } catch (...) {
31135       {
31136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31137       };
31138     }
31139   }
31140
31141   jresult = result;
31142   return jresult;
31143 }
31144
31145
31146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31147   unsigned int jresult ;
31148   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31149   bool result;
31150
31151   arg1 = (Dali::KeyEvent *)jarg1;
31152   {
31153     try {
31154       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31155     } catch (std::out_of_range& e) {
31156       {
31157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31158       };
31159     } catch (std::exception& e) {
31160       {
31161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31162       };
31163     } catch (Dali::DaliException e) {
31164       {
31165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31166       };
31167     } catch (...) {
31168       {
31169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31170       };
31171     }
31172   }
31173
31174   jresult = result;
31175   return jresult;
31176 }
31177
31178
31179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31180   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31181   std::string *arg2 = 0 ;
31182
31183   arg1 = (Dali::KeyEvent *)jarg1;
31184   if (!jarg2) {
31185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31186     return ;
31187   }
31188   std::string arg2_str(jarg2);
31189   arg2 = &arg2_str;
31190   if (arg1) (arg1)->keyPressedName = *arg2;
31191
31192   //argout typemap for const std::string&
31193
31194 }
31195
31196
31197 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31198   char * jresult ;
31199
31200   if( jarg1 == NULL )
31201   {
31202     jresult = SWIG_csharp_string_callback( "" );
31203   }
31204   else
31205   {
31206     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31207     std::string *result = 0;
31208
31209     arg1 = ( Dali::KeyEvent * )jarg1;
31210     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31211     jresult = SWIG_csharp_string_callback( result->c_str() );
31212   }
31213
31214   return jresult;
31215 }
31216
31217
31218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31219   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31220   std::string *arg2 = 0 ;
31221
31222   arg1 = (Dali::KeyEvent *)jarg1;
31223   if (!jarg2) {
31224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31225     return ;
31226   }
31227   std::string arg2_str(jarg2);
31228   arg2 = &arg2_str;
31229   if (arg1) (arg1)->keyPressed = *arg2;
31230
31231   //argout typemap for const std::string&
31232
31233 }
31234
31235
31236 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31237   char * jresult ;
31238   if( NULL == jarg1 )
31239   {
31240     jresult = SWIG_csharp_string_callback( "" );
31241   }
31242   else
31243   {
31244     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31245     std::string *result = 0;
31246
31247     arg1 = ( Dali::KeyEvent * )jarg1;
31248     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31249     jresult = SWIG_csharp_string_callback( result->c_str() );
31250   }
31251   return jresult;
31252 }
31253
31254
31255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31256   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31257   int arg2 ;
31258
31259   arg1 = (Dali::KeyEvent *)jarg1;
31260   arg2 = (int)jarg2;
31261   if (arg1) (arg1)->keyCode = arg2;
31262 }
31263
31264
31265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31266   int jresult ;
31267   if( NULL == jarg1 )
31268   {
31269     jresult = -1;
31270   }
31271   else
31272   {
31273     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31274     int result;
31275
31276     arg1 = ( Dali::KeyEvent * )jarg1;
31277     result = (int)( ( arg1 )->keyCode );
31278     jresult = result;
31279   }
31280   return jresult;
31281 }
31282
31283
31284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31285   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31286   int arg2 ;
31287
31288   arg1 = (Dali::KeyEvent *)jarg1;
31289   arg2 = (int)jarg2;
31290   if (arg1) (arg1)->keyModifier = arg2;
31291 }
31292
31293
31294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31295   int jresult ;
31296   if( jarg1 == NULL )
31297   {
31298     jresult = -1;
31299   }
31300   else
31301   {
31302     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31303     int result;
31304
31305     arg1 = ( Dali::KeyEvent * )jarg1;
31306     result = (int)( ( arg1 )->keyModifier );
31307     jresult = result;
31308   }
31309   return jresult;
31310 }
31311
31312
31313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31314   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31315   unsigned long arg2 ;
31316
31317   arg1 = (Dali::KeyEvent *)jarg1;
31318   arg2 = (unsigned long)jarg2;
31319   if (arg1) (arg1)->time = arg2;
31320 }
31321
31322
31323 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31324   unsigned long jresult ;
31325   if( jarg1 == NULL )
31326   {
31327     jresult = 0;
31328   }
31329   else
31330   {
31331     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31332     unsigned long result;
31333
31334     arg1 = ( Dali::KeyEvent * )jarg1;
31335     result = (unsigned long)( ( arg1 )->time );
31336     jresult = (unsigned long)result;
31337   }
31338   return jresult;
31339 }
31340
31341
31342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31343   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31344   Dali::KeyEvent::State arg2 ;
31345
31346   arg1 = (Dali::KeyEvent *)jarg1;
31347   arg2 = (Dali::KeyEvent::State)jarg2;
31348   if (arg1) (arg1)->state = arg2;
31349 }
31350
31351
31352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31353   int jresult ;
31354   if( jarg1 == NULL )
31355   {
31356     jresult = -1;
31357   }
31358   else
31359   {
31360     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31361     Dali::KeyEvent::State result;
31362
31363     arg1 = ( Dali::KeyEvent * )jarg1;
31364     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31365     jresult = (int)result;
31366   }
31367   return jresult;
31368 }
31369
31370 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31371   char * jresult ;
31372   std::string result;
31373   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31374
31375   arg1 = (Dali::KeyEvent *)jarg1;
31376   if (!arg1) {
31377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31378     return 0;
31379   }
31380   {
31381     try {
31382       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31383     } catch (std::out_of_range& e) {
31384       {
31385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31386       };
31387     } catch (std::exception& e) {
31388       {
31389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31390       };
31391     } catch (Dali::DaliException e) {
31392       {
31393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31394       };
31395     } catch (...) {
31396       {
31397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31398       };
31399     }
31400
31401   }
31402
31403   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31404   return jresult;
31405 }
31406
31407
31408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31409   void * jresult ;
31410   Dali::LongPressGestureDetector *result = 0 ;
31411
31412   {
31413     try {
31414       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31415     } catch (std::out_of_range& e) {
31416       {
31417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31418       };
31419     } catch (std::exception& e) {
31420       {
31421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31422       };
31423     } catch (Dali::DaliException e) {
31424       {
31425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31426       };
31427     } catch (...) {
31428       {
31429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31430       };
31431     }
31432   }
31433
31434   jresult = (void *)result;
31435   return jresult;
31436 }
31437
31438
31439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31440   void * jresult ;
31441   Dali::LongPressGestureDetector result;
31442
31443   {
31444     try {
31445       result = Dali::LongPressGestureDetector::New();
31446     } catch (std::out_of_range& e) {
31447       {
31448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31449       };
31450     } catch (std::exception& e) {
31451       {
31452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31453       };
31454     } catch (Dali::DaliException e) {
31455       {
31456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31457       };
31458     } catch (...) {
31459       {
31460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31461       };
31462     }
31463   }
31464
31465   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31466   return jresult;
31467 }
31468
31469
31470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31471   void * jresult ;
31472   unsigned int arg1 ;
31473   Dali::LongPressGestureDetector result;
31474
31475   arg1 = (unsigned int)jarg1;
31476   {
31477     try {
31478       result = Dali::LongPressGestureDetector::New(arg1);
31479     } catch (std::out_of_range& e) {
31480       {
31481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31482       };
31483     } catch (std::exception& e) {
31484       {
31485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31486       };
31487     } catch (Dali::DaliException e) {
31488       {
31489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31490       };
31491     } catch (...) {
31492       {
31493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31494       };
31495     }
31496   }
31497
31498   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31499   return jresult;
31500 }
31501
31502
31503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31504   void * jresult ;
31505   unsigned int arg1 ;
31506   unsigned int arg2 ;
31507   Dali::LongPressGestureDetector result;
31508
31509   arg1 = (unsigned int)jarg1;
31510   arg2 = (unsigned int)jarg2;
31511   {
31512     try {
31513       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31514     } catch (std::out_of_range& e) {
31515       {
31516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31517       };
31518     } catch (std::exception& e) {
31519       {
31520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31521       };
31522     } catch (Dali::DaliException e) {
31523       {
31524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31525       };
31526     } catch (...) {
31527       {
31528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31529       };
31530     }
31531   }
31532
31533   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31534   return jresult;
31535 }
31536
31537
31538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31539   void * jresult ;
31540   Dali::BaseHandle arg1 ;
31541   Dali::BaseHandle *argp1 ;
31542   Dali::LongPressGestureDetector result;
31543
31544   argp1 = (Dali::BaseHandle *)jarg1;
31545   if (!argp1) {
31546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31547     return 0;
31548   }
31549   arg1 = *argp1;
31550   {
31551     try {
31552       result = Dali::LongPressGestureDetector::DownCast(arg1);
31553     } catch (std::out_of_range& e) {
31554       {
31555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31556       };
31557     } catch (std::exception& e) {
31558       {
31559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31560       };
31561     } catch (Dali::DaliException e) {
31562       {
31563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31564       };
31565     } catch (...) {
31566       {
31567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31568       };
31569     }
31570   }
31571
31572   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31573   return jresult;
31574 }
31575
31576
31577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31578   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31579
31580   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31581   {
31582     try {
31583       delete arg1;
31584     } catch (std::out_of_range& e) {
31585       {
31586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31587       };
31588     } catch (std::exception& e) {
31589       {
31590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31591       };
31592     } catch (Dali::DaliException e) {
31593       {
31594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31595       };
31596     } catch (...) {
31597       {
31598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31599       };
31600     }
31601   }
31602
31603 }
31604
31605
31606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31607   void * jresult ;
31608   Dali::LongPressGestureDetector *arg1 = 0 ;
31609   Dali::LongPressGestureDetector *result = 0 ;
31610
31611   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31612   if (!arg1) {
31613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31614     return 0;
31615   }
31616   {
31617     try {
31618       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31619     } catch (std::out_of_range& e) {
31620       {
31621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31622       };
31623     } catch (std::exception& e) {
31624       {
31625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31626       };
31627     } catch (Dali::DaliException e) {
31628       {
31629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31630       };
31631     } catch (...) {
31632       {
31633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31634       };
31635     }
31636   }
31637
31638   jresult = (void *)result;
31639   return jresult;
31640 }
31641
31642
31643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31644   void * jresult ;
31645   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31646   Dali::LongPressGestureDetector *arg2 = 0 ;
31647   Dali::LongPressGestureDetector *result = 0 ;
31648
31649   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31650   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31651   if (!arg2) {
31652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31653     return 0;
31654   }
31655   {
31656     try {
31657       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31658     } catch (std::out_of_range& e) {
31659       {
31660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31661       };
31662     } catch (std::exception& e) {
31663       {
31664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31665       };
31666     } catch (Dali::DaliException e) {
31667       {
31668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31669       };
31670     } catch (...) {
31671       {
31672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31673       };
31674     }
31675   }
31676
31677   jresult = (void *)result;
31678   return jresult;
31679 }
31680
31681
31682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31683   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31684   unsigned int arg2 ;
31685
31686   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31687   arg2 = (unsigned int)jarg2;
31688   {
31689     try {
31690       (arg1)->SetTouchesRequired(arg2);
31691     } catch (std::out_of_range& e) {
31692       {
31693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31694       };
31695     } catch (std::exception& e) {
31696       {
31697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31698       };
31699     } catch (Dali::DaliException e) {
31700       {
31701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31702       };
31703     } catch (...) {
31704       {
31705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31706       };
31707     }
31708   }
31709
31710 }
31711
31712
31713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31714   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31715   unsigned int arg2 ;
31716   unsigned int arg3 ;
31717
31718   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31719   arg2 = (unsigned int)jarg2;
31720   arg3 = (unsigned int)jarg3;
31721   {
31722     try {
31723       (arg1)->SetTouchesRequired(arg2,arg3);
31724     } catch (std::out_of_range& e) {
31725       {
31726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31727       };
31728     } catch (std::exception& e) {
31729       {
31730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31731       };
31732     } catch (Dali::DaliException e) {
31733       {
31734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31735       };
31736     } catch (...) {
31737       {
31738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31739       };
31740     }
31741   }
31742
31743 }
31744
31745
31746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31747   unsigned int jresult ;
31748   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31749   unsigned int result;
31750
31751   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31752   {
31753     try {
31754       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31755     } catch (std::out_of_range& e) {
31756       {
31757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31758       };
31759     } catch (std::exception& e) {
31760       {
31761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31762       };
31763     } catch (Dali::DaliException e) {
31764       {
31765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31766       };
31767     } catch (...) {
31768       {
31769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31770       };
31771     }
31772   }
31773
31774   jresult = result;
31775   return jresult;
31776 }
31777
31778
31779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31780   unsigned int jresult ;
31781   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31782   unsigned int result;
31783
31784   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31785   {
31786     try {
31787       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31788     } catch (std::out_of_range& e) {
31789       {
31790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31791       };
31792     } catch (std::exception& e) {
31793       {
31794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31795       };
31796     } catch (Dali::DaliException e) {
31797       {
31798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31799       };
31800     } catch (...) {
31801       {
31802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31803       };
31804     }
31805   }
31806
31807   jresult = result;
31808   return jresult;
31809 }
31810
31811
31812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31813   void * jresult ;
31814   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31815   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31816
31817   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31818   {
31819     try {
31820       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31821     } catch (std::out_of_range& e) {
31822       {
31823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31824       };
31825     } catch (std::exception& e) {
31826       {
31827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31828       };
31829     } catch (Dali::DaliException e) {
31830       {
31831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31832       };
31833     } catch (...) {
31834       {
31835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31836       };
31837     }
31838   }
31839
31840   jresult = (void *)result;
31841   return jresult;
31842 }
31843
31844
31845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31846   void * jresult ;
31847   Dali::Gesture::State arg1 ;
31848   Dali::LongPressGesture *result = 0 ;
31849
31850   arg1 = (Dali::Gesture::State)jarg1;
31851   {
31852     try {
31853       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31854     } catch (std::out_of_range& e) {
31855       {
31856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31857       };
31858     } catch (std::exception& e) {
31859       {
31860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31861       };
31862     } catch (Dali::DaliException e) {
31863       {
31864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31865       };
31866     } catch (...) {
31867       {
31868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31869       };
31870     }
31871   }
31872
31873   jresult = (void *)result;
31874   return jresult;
31875 }
31876
31877
31878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31879   void * jresult ;
31880   Dali::LongPressGesture *arg1 = 0 ;
31881   Dali::LongPressGesture *result = 0 ;
31882
31883   arg1 = (Dali::LongPressGesture *)jarg1;
31884   if (!arg1) {
31885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31886     return 0;
31887   }
31888   {
31889     try {
31890       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31891     } catch (std::out_of_range& e) {
31892       {
31893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31894       };
31895     } catch (std::exception& e) {
31896       {
31897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31898       };
31899     } catch (Dali::DaliException e) {
31900       {
31901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31902       };
31903     } catch (...) {
31904       {
31905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31906       };
31907     }
31908   }
31909
31910   jresult = (void *)result;
31911   return jresult;
31912 }
31913
31914
31915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31916   void * jresult ;
31917   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31918   Dali::LongPressGesture *arg2 = 0 ;
31919   Dali::LongPressGesture *result = 0 ;
31920
31921   arg1 = (Dali::LongPressGesture *)jarg1;
31922   arg2 = (Dali::LongPressGesture *)jarg2;
31923   if (!arg2) {
31924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31925     return 0;
31926   }
31927   {
31928     try {
31929       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31930     } catch (std::out_of_range& e) {
31931       {
31932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31933       };
31934     } catch (std::exception& e) {
31935       {
31936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31937       };
31938     } catch (Dali::DaliException e) {
31939       {
31940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31941       };
31942     } catch (...) {
31943       {
31944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31945       };
31946     }
31947   }
31948
31949   jresult = (void *)result;
31950   return jresult;
31951 }
31952
31953
31954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
31955   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31956
31957   arg1 = (Dali::LongPressGesture *)jarg1;
31958   {
31959     try {
31960       delete arg1;
31961     } catch (std::out_of_range& e) {
31962       {
31963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31964       };
31965     } catch (std::exception& e) {
31966       {
31967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31968       };
31969     } catch (Dali::DaliException e) {
31970       {
31971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31972       };
31973     } catch (...) {
31974       {
31975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31976       };
31977     }
31978   }
31979
31980 }
31981
31982
31983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
31984   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31985   unsigned int arg2 ;
31986
31987   arg1 = (Dali::LongPressGesture *)jarg1;
31988   arg2 = (unsigned int)jarg2;
31989   if (arg1) (arg1)->numberOfTouches = arg2;
31990 }
31991
31992
31993 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
31994   unsigned int jresult ;
31995   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31996   unsigned int result;
31997
31998   arg1 = (Dali::LongPressGesture *)jarg1;
31999   result = (unsigned int) ((arg1)->numberOfTouches);
32000   jresult = result;
32001   return jresult;
32002 }
32003
32004
32005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32006   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32007   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32008
32009   arg1 = (Dali::LongPressGesture *)jarg1;
32010   arg2 = (Dali::Vector2 *)jarg2;
32011   if (arg1) (arg1)->screenPoint = *arg2;
32012 }
32013
32014
32015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32016   void * jresult ;
32017   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32018   Dali::Vector2 *result = 0 ;
32019
32020   arg1 = (Dali::LongPressGesture *)jarg1;
32021   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32022   jresult = (void *)result;
32023   return jresult;
32024 }
32025
32026
32027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32028   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32029   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32030
32031   arg1 = (Dali::LongPressGesture *)jarg1;
32032   arg2 = (Dali::Vector2 *)jarg2;
32033   if (arg1) (arg1)->localPoint = *arg2;
32034 }
32035
32036
32037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32038   void * jresult ;
32039   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32040   Dali::Vector2 *result = 0 ;
32041
32042   arg1 = (Dali::LongPressGesture *)jarg1;
32043   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32044   jresult = (void *)result;
32045   return jresult;
32046 }
32047
32048
32049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32050   void * jresult ;
32051   Dali::WheelEvent *result = 0 ;
32052
32053   {
32054     try {
32055       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32056     } catch (std::out_of_range& e) {
32057       {
32058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32059       };
32060     } catch (std::exception& e) {
32061       {
32062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32063       };
32064     } catch (Dali::DaliException e) {
32065       {
32066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32067       };
32068     } catch (...) {
32069       {
32070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32071       };
32072     }
32073   }
32074
32075   jresult = (void *)result;
32076   return jresult;
32077 }
32078
32079
32080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32081   void * jresult ;
32082   Dali::WheelEvent::Type arg1 ;
32083   int arg2 ;
32084   unsigned int arg3 ;
32085   Dali::Vector2 arg4 ;
32086   int arg5 ;
32087   unsigned int arg6 ;
32088   Dali::Vector2 *argp4 ;
32089   Dali::WheelEvent *result = 0 ;
32090
32091   arg1 = (Dali::WheelEvent::Type)jarg1;
32092   arg2 = (int)jarg2;
32093   arg3 = (unsigned int)jarg3;
32094   argp4 = (Dali::Vector2 *)jarg4;
32095   if (!argp4) {
32096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32097     return 0;
32098   }
32099   arg4 = *argp4;
32100   arg5 = (int)jarg5;
32101   arg6 = (unsigned int)jarg6;
32102   {
32103     try {
32104       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32105     } catch (std::out_of_range& e) {
32106       {
32107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32108       };
32109     } catch (std::exception& e) {
32110       {
32111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32112       };
32113     } catch (Dali::DaliException e) {
32114       {
32115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32116       };
32117     } catch (...) {
32118       {
32119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32120       };
32121     }
32122   }
32123
32124   jresult = (void *)result;
32125   return jresult;
32126 }
32127
32128
32129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32130   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32131
32132   arg1 = (Dali::WheelEvent *)jarg1;
32133   {
32134     try {
32135       delete arg1;
32136     } catch (std::out_of_range& e) {
32137       {
32138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32139       };
32140     } catch (std::exception& e) {
32141       {
32142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32143       };
32144     } catch (Dali::DaliException e) {
32145       {
32146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32147       };
32148     } catch (...) {
32149       {
32150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32151       };
32152     }
32153   }
32154
32155 }
32156
32157
32158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32159   unsigned int jresult ;
32160   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32161   bool result;
32162
32163   arg1 = (Dali::WheelEvent *)jarg1;
32164   {
32165     try {
32166       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32167     } catch (std::out_of_range& e) {
32168       {
32169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32170       };
32171     } catch (std::exception& e) {
32172       {
32173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32174       };
32175     } catch (Dali::DaliException e) {
32176       {
32177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32178       };
32179     } catch (...) {
32180       {
32181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32182       };
32183     }
32184   }
32185
32186   jresult = result;
32187   return jresult;
32188 }
32189
32190
32191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32192   unsigned int jresult ;
32193   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32194   bool result;
32195
32196   arg1 = (Dali::WheelEvent *)jarg1;
32197   {
32198     try {
32199       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32200     } catch (std::out_of_range& e) {
32201       {
32202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32203       };
32204     } catch (std::exception& e) {
32205       {
32206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32207       };
32208     } catch (Dali::DaliException e) {
32209       {
32210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32211       };
32212     } catch (...) {
32213       {
32214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32215       };
32216     }
32217   }
32218
32219   jresult = result;
32220   return jresult;
32221 }
32222
32223
32224 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32225   unsigned int jresult ;
32226   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32227   bool result;
32228
32229   arg1 = (Dali::WheelEvent *)jarg1;
32230   {
32231     try {
32232       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32233     } catch (std::out_of_range& e) {
32234       {
32235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32236       };
32237     } catch (std::exception& e) {
32238       {
32239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32240       };
32241     } catch (Dali::DaliException e) {
32242       {
32243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32244       };
32245     } catch (...) {
32246       {
32247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32248       };
32249     }
32250   }
32251
32252   jresult = result;
32253   return jresult;
32254 }
32255
32256
32257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32258   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32259   Dali::WheelEvent::Type arg2 ;
32260
32261   arg1 = (Dali::WheelEvent *)jarg1;
32262   arg2 = (Dali::WheelEvent::Type)jarg2;
32263   if (arg1) (arg1)->type = arg2;
32264 }
32265
32266
32267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32268   int jresult ;
32269   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32270   Dali::WheelEvent::Type result;
32271
32272   arg1 = (Dali::WheelEvent *)jarg1;
32273   result = (Dali::WheelEvent::Type) ((arg1)->type);
32274   jresult = (int)result;
32275   return jresult;
32276 }
32277
32278
32279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32280   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32281   int arg2 ;
32282
32283   arg1 = (Dali::WheelEvent *)jarg1;
32284   arg2 = (int)jarg2;
32285   if (arg1) (arg1)->direction = arg2;
32286 }
32287
32288
32289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32290   int jresult ;
32291   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32292   int result;
32293
32294   arg1 = (Dali::WheelEvent *)jarg1;
32295   result = (int) ((arg1)->direction);
32296   jresult = result;
32297   return jresult;
32298 }
32299
32300
32301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32302   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32303   unsigned int arg2 ;
32304
32305   arg1 = (Dali::WheelEvent *)jarg1;
32306   arg2 = (unsigned int)jarg2;
32307   if (arg1) (arg1)->modifiers = arg2;
32308 }
32309
32310
32311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32312   unsigned int jresult ;
32313   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32314   unsigned int result;
32315
32316   arg1 = (Dali::WheelEvent *)jarg1;
32317   result = (unsigned int) ((arg1)->modifiers);
32318   jresult = result;
32319   return jresult;
32320 }
32321
32322
32323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32324   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32325   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32326
32327   arg1 = (Dali::WheelEvent *)jarg1;
32328   arg2 = (Dali::Vector2 *)jarg2;
32329   if (arg1) (arg1)->point = *arg2;
32330 }
32331
32332
32333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32334   void * jresult ;
32335   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32336   Dali::Vector2 *result = 0 ;
32337
32338   arg1 = (Dali::WheelEvent *)jarg1;
32339   result = (Dali::Vector2 *)& ((arg1)->point);
32340   jresult = (void *)result;
32341   return jresult;
32342 }
32343
32344
32345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32346   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32347   int arg2 ;
32348
32349   arg1 = (Dali::WheelEvent *)jarg1;
32350   arg2 = (int)jarg2;
32351   if (arg1) (arg1)->z = arg2;
32352 }
32353
32354
32355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32356   int jresult ;
32357   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32358   int result;
32359
32360   arg1 = (Dali::WheelEvent *)jarg1;
32361   result = (int) ((arg1)->z);
32362   jresult = result;
32363   return jresult;
32364 }
32365
32366
32367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32368   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32369   unsigned int arg2 ;
32370
32371   arg1 = (Dali::WheelEvent *)jarg1;
32372   arg2 = (unsigned int)jarg2;
32373   if (arg1) (arg1)->timeStamp = arg2;
32374 }
32375
32376
32377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32378   unsigned int jresult ;
32379   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32380   unsigned int result;
32381
32382   arg1 = (Dali::WheelEvent *)jarg1;
32383   result = (unsigned int) ((arg1)->timeStamp);
32384   jresult = result;
32385   return jresult;
32386 }
32387
32388 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32389   char * jresult ;
32390   Dali::KeyEvent *arg1 = 0 ;
32391   std::string result;
32392
32393   arg1 = (Dali::KeyEvent *)jarg1;
32394   if (!arg1) {
32395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32396     return 0;
32397   }
32398   {
32399     try {
32400       result = arg1->GetDeviceName();
32401     } catch (std::out_of_range& e) {
32402       {
32403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32404       };
32405     } catch (std::exception& e) {
32406       {
32407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32408       };
32409     } catch (Dali::DaliException e) {
32410       {
32411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32412       };
32413     } catch (...) {
32414       {
32415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32416       };
32417     }
32418   }
32419
32420   jresult = SWIG_csharp_string_callback((&result)->c_str());
32421   return jresult;
32422 }
32423
32424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32425   int jresult ;
32426   Dali::KeyEvent *arg1 = 0 ;
32427   Dali::Device::Class::Type result;
32428
32429   arg1 = (Dali::KeyEvent *)jarg1;
32430   if (!arg1) {
32431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32432     return 0;
32433   }
32434   {
32435     try {
32436       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32437     } catch (std::out_of_range& e) {
32438       {
32439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32440       };
32441     } catch (std::exception& e) {
32442       {
32443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32444       };
32445     } catch (Dali::DaliException e) {
32446       {
32447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32448       };
32449     } catch (...) {
32450       {
32451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32452       };
32453     }
32454   }
32455
32456   jresult = (int)result;
32457   return jresult;
32458 }
32459
32460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32461   int jresult ;
32462   Dali::KeyEvent *arg1 = 0 ;
32463   Dali::Device::Subclass::Type result;
32464
32465   arg1 = (Dali::KeyEvent *)jarg1;
32466   if (!arg1) {
32467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32468     return 0;
32469   }
32470   {
32471     try {
32472       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32473     } catch (std::out_of_range& e) {
32474       {
32475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32476       };
32477     } catch (std::exception& e) {
32478       {
32479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32480       };
32481     } catch (Dali::DaliException e) {
32482       {
32483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32484       };
32485     } catch (...) {
32486       {
32487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32488       };
32489     }
32490   }
32491
32492   jresult = (int)result;
32493   return jresult;
32494 }
32495
32496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32497   Dali::Actor arg1 ;
32498   Dali::Actor *argp1 ;
32499
32500   argp1 = (Dali::Actor *)jarg1;
32501   if (!argp1) {
32502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32503     return ;
32504   }
32505   arg1 = *argp1;
32506   {
32507     try {
32508       arg1.Raise();
32509     } catch (std::out_of_range& e) {
32510       {
32511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32512       };
32513     } catch (std::exception& e) {
32514       {
32515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32516       };
32517     } catch (Dali::DaliException e) {
32518       {
32519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32520       };
32521     } catch (...) {
32522       {
32523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32524       };
32525     }
32526   }
32527
32528 }
32529
32530
32531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32532   Dali::Actor arg1 ;
32533   Dali::Actor *argp1 ;
32534
32535   argp1 = (Dali::Actor *)jarg1;
32536   if (!argp1) {
32537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32538     return ;
32539   }
32540   arg1 = *argp1;
32541   {
32542     try {
32543       arg1.Lower();
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_RaiseToTop(void * jarg1) {
32567   Dali::Actor arg1 ;
32568   Dali::Actor *argp1 ;
32569
32570   argp1 = (Dali::Actor *)jarg1;
32571   if (!argp1) {
32572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32573     return ;
32574   }
32575   arg1 = *argp1;
32576   {
32577     try {
32578       arg1.RaiseToTop();
32579     } catch (std::out_of_range& e) {
32580       {
32581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32582       };
32583     } catch (std::exception& e) {
32584       {
32585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32586       };
32587     } catch (Dali::DaliException e) {
32588       {
32589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32590       };
32591     } catch (...) {
32592       {
32593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32594       };
32595     }
32596   }
32597
32598 }
32599
32600
32601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32602   Dali::Actor arg1 ;
32603   Dali::Actor *argp1 ;
32604
32605   argp1 = (Dali::Actor *)jarg1;
32606   if (!argp1) {
32607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32608     return ;
32609   }
32610   arg1 = *argp1;
32611   {
32612     try {
32613       arg1.LowerToBottom();
32614     } catch (std::out_of_range& e) {
32615       {
32616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32617       };
32618     } catch (std::exception& e) {
32619       {
32620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32621       };
32622     } catch (Dali::DaliException e) {
32623       {
32624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32625       };
32626     } catch (...) {
32627       {
32628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32629       };
32630     }
32631   }
32632
32633 }
32634
32635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32636   Dali::Actor arg1 ;
32637   Dali::Actor arg2 ;
32638   Dali::Actor *argp1 ;
32639   Dali::Actor *argp2 ;
32640
32641   argp1 = (Dali::Actor *)jarg1;
32642   if (!argp1) {
32643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32644     return ;
32645   }
32646   arg1 = *argp1;
32647   argp2 = (Dali::Actor *)jarg2;
32648   if (!argp2) {
32649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32650     return ;
32651   }
32652   arg2 = *argp2;
32653   {
32654     try {
32655       arg1.RaiseAbove(arg2);
32656     } catch (std::out_of_range& e) {
32657       {
32658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32659       };
32660     } catch (std::exception& e) {
32661       {
32662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32663       };
32664     } catch (Dali::DaliException e) {
32665       {
32666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32667       };
32668     } catch (...) {
32669       {
32670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32671       };
32672     }
32673   }
32674
32675 }
32676
32677
32678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32679   Dali::Actor arg1 ;
32680   Dali::Actor arg2 ;
32681   Dali::Actor *argp1 ;
32682   Dali::Actor *argp2 ;
32683
32684   argp1 = (Dali::Actor *)jarg1;
32685   if (!argp1) {
32686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32687     return ;
32688   }
32689   arg1 = *argp1;
32690   argp2 = (Dali::Actor *)jarg2;
32691   if (!argp2) {
32692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32693     return ;
32694   }
32695   arg2 = *argp2;
32696   {
32697     try {
32698       arg1.LowerBelow(arg2);
32699     } catch (std::out_of_range& e) {
32700       {
32701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32702       };
32703     } catch (std::exception& e) {
32704       {
32705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32706       };
32707     } catch (Dali::DaliException e) {
32708       {
32709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32710       };
32711     } catch (...) {
32712       {
32713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32714       };
32715     }
32716   }
32717
32718 }
32719
32720
32721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32722   void * jresult ;
32723   Dali::Actor arg1 ;
32724   Dali::Actor *argp1 ;
32725   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32726
32727   argp1 = (Dali::Actor *)jarg1;
32728   if (!argp1) {
32729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32730     return 0;
32731   }
32732   arg1 = *argp1;
32733   {
32734     try {
32735       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32736     } catch (std::out_of_range& e) {
32737       {
32738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32739       };
32740     } catch (std::exception& e) {
32741       {
32742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32743       };
32744     } catch (Dali::DaliException e) {
32745       {
32746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32747       };
32748     } catch (...) {
32749       {
32750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32751       };
32752     }
32753   }
32754
32755   jresult = (void *)result;
32756   return jresult;
32757 }
32758
32759
32760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32761   void * jresult ;
32762   Dali::Actor *arg1 ;
32763   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32764
32765   arg1 = (Dali::Actor *)jarg1;
32766   {
32767     try {
32768       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32769     } catch (std::out_of_range& e) {
32770       {
32771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32772       };
32773     } catch (std::exception& e) {
32774       {
32775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32776       };
32777     } catch (Dali::DaliException e) {
32778       {
32779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32780       };
32781     } catch (...) {
32782       {
32783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32784       };
32785     }
32786   }
32787
32788   jresult = (void *)result;
32789   return jresult;
32790 }
32791
32792
32793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32794   int jresult ;
32795   int result;
32796
32797   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32798   jresult = (int)result;
32799   return jresult;
32800 }
32801
32802
32803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32804   int jresult ;
32805   int result;
32806
32807   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32808   jresult = (int)result;
32809   return jresult;
32810 }
32811
32812
32813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32814   int jresult ;
32815   int result;
32816
32817   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32818   jresult = (int)result;
32819   return jresult;
32820 }
32821
32822
32823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32824   int jresult ;
32825   int result;
32826
32827   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32828   jresult = (int)result;
32829   return jresult;
32830 }
32831
32832
32833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32834   int jresult ;
32835   int result;
32836
32837   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32838   jresult = (int)result;
32839   return jresult;
32840 }
32841
32842
32843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32844   int jresult ;
32845   int result;
32846
32847   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32848   jresult = (int)result;
32849   return jresult;
32850 }
32851
32852
32853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32854   int jresult ;
32855   int result;
32856
32857   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32858   jresult = (int)result;
32859   return jresult;
32860 }
32861
32862
32863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32864   int jresult ;
32865   int result;
32866
32867   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32868   jresult = (int)result;
32869   return jresult;
32870 }
32871
32872
32873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32874   int jresult ;
32875   int result;
32876
32877   result = (int)Dali::Actor::Property::SIZE;
32878   jresult = (int)result;
32879   return jresult;
32880 }
32881
32882
32883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32884   int jresult ;
32885   int result;
32886
32887   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32888   jresult = (int)result;
32889   return jresult;
32890 }
32891
32892
32893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32894   int jresult ;
32895   int result;
32896
32897   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32898   jresult = (int)result;
32899   return jresult;
32900 }
32901
32902
32903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32904   int jresult ;
32905   int result;
32906
32907   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32908   jresult = (int)result;
32909   return jresult;
32910 }
32911
32912
32913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32914   int jresult ;
32915   int result;
32916
32917   result = (int)Dali::Actor::Property::POSITION;
32918   jresult = (int)result;
32919   return jresult;
32920 }
32921
32922
32923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32924   int jresult ;
32925   int result;
32926
32927   result = (int)Dali::Actor::Property::POSITION_X;
32928   jresult = (int)result;
32929   return jresult;
32930 }
32931
32932
32933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32934   int jresult ;
32935   int result;
32936
32937   result = (int)Dali::Actor::Property::POSITION_Y;
32938   jresult = (int)result;
32939   return jresult;
32940 }
32941
32942
32943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32944   int jresult ;
32945   int result;
32946
32947   result = (int)Dali::Actor::Property::POSITION_Z;
32948   jresult = (int)result;
32949   return jresult;
32950 }
32951
32952
32953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
32954   int jresult ;
32955   int result;
32956
32957   result = (int)Dali::Actor::Property::WORLD_POSITION;
32958   jresult = (int)result;
32959   return jresult;
32960 }
32961
32962
32963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
32964   int jresult ;
32965   int result;
32966
32967   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
32968   jresult = (int)result;
32969   return jresult;
32970 }
32971
32972
32973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
32974   int jresult ;
32975   int result;
32976
32977   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
32978   jresult = (int)result;
32979   return jresult;
32980 }
32981
32982
32983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
32984   int jresult ;
32985   int result;
32986
32987   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
32988   jresult = (int)result;
32989   return jresult;
32990 }
32991
32992
32993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
32994   int jresult ;
32995   int result;
32996
32997   result = (int)Dali::Actor::Property::ORIENTATION;
32998   jresult = (int)result;
32999   return jresult;
33000 }
33001
33002
33003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33004   int jresult ;
33005   int result;
33006
33007   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33008   jresult = (int)result;
33009   return jresult;
33010 }
33011
33012
33013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33014   int jresult ;
33015   int result;
33016
33017   result = (int)Dali::Actor::Property::SCALE;
33018   jresult = (int)result;
33019   return jresult;
33020 }
33021
33022
33023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33024   int jresult ;
33025   int result;
33026
33027   result = (int)Dali::Actor::Property::SCALE_X;
33028   jresult = (int)result;
33029   return jresult;
33030 }
33031
33032
33033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33034   int jresult ;
33035   int result;
33036
33037   result = (int)Dali::Actor::Property::SCALE_Y;
33038   jresult = (int)result;
33039   return jresult;
33040 }
33041
33042
33043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33044   int jresult ;
33045   int result;
33046
33047   result = (int)Dali::Actor::Property::SCALE_Z;
33048   jresult = (int)result;
33049   return jresult;
33050 }
33051
33052
33053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33054   int jresult ;
33055   int result;
33056
33057   result = (int)Dali::Actor::Property::WORLD_SCALE;
33058   jresult = (int)result;
33059   return jresult;
33060 }
33061
33062
33063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33064   int jresult ;
33065   int result;
33066
33067   result = (int)Dali::Actor::Property::VISIBLE;
33068   jresult = (int)result;
33069   return jresult;
33070 }
33071
33072
33073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33074   int jresult ;
33075   int result;
33076
33077   result = (int)Dali::Actor::Property::COLOR;
33078   jresult = (int)result;
33079   return jresult;
33080 }
33081
33082
33083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33084   int jresult ;
33085   int result;
33086
33087   result = (int)Dali::Actor::Property::COLOR_RED;
33088   jresult = (int)result;
33089   return jresult;
33090 }
33091
33092
33093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33094   int jresult ;
33095   int result;
33096
33097   result = (int)Dali::Actor::Property::COLOR_GREEN;
33098   jresult = (int)result;
33099   return jresult;
33100 }
33101
33102
33103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33104   int jresult ;
33105   int result;
33106
33107   result = (int)Dali::Actor::Property::COLOR_BLUE;
33108   jresult = (int)result;
33109   return jresult;
33110 }
33111
33112
33113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33114   int jresult ;
33115   int result;
33116
33117   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33118   jresult = (int)result;
33119   return jresult;
33120 }
33121
33122
33123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33124   int jresult ;
33125   int result;
33126
33127   result = (int)Dali::Actor::Property::WORLD_COLOR;
33128   jresult = (int)result;
33129   return jresult;
33130 }
33131
33132
33133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33134   int jresult ;
33135   int result;
33136
33137   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33138   jresult = (int)result;
33139   return jresult;
33140 }
33141
33142
33143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33144   int jresult ;
33145   int result;
33146
33147   result = (int)Dali::Actor::Property::NAME;
33148   jresult = (int)result;
33149   return jresult;
33150 }
33151
33152
33153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33154   int jresult ;
33155   int result;
33156
33157   result = (int)Dali::Actor::Property::SENSITIVE;
33158   jresult = (int)result;
33159   return jresult;
33160 }
33161
33162
33163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33164   int jresult ;
33165   int result;
33166
33167   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33168   jresult = (int)result;
33169   return jresult;
33170 }
33171
33172
33173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33174   int jresult ;
33175   int result;
33176
33177   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33178   jresult = (int)result;
33179   return jresult;
33180 }
33181
33182
33183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33184   int jresult ;
33185   int result;
33186
33187   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33188   jresult = (int)result;
33189   return jresult;
33190 }
33191
33192
33193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33194   int jresult ;
33195   int result;
33196
33197   result = (int)Dali::Actor::Property::COLOR_MODE;
33198   jresult = (int)result;
33199   return jresult;
33200 }
33201
33202
33203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33204   int jresult ;
33205   int result;
33206
33207   result = (int)Dali::Actor::Property::DRAW_MODE;
33208   jresult = (int)result;
33209   return jresult;
33210 }
33211
33212
33213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33214   int jresult ;
33215   int result;
33216
33217   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33218   jresult = (int)result;
33219   return jresult;
33220 }
33221
33222
33223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33224   int jresult ;
33225   int result;
33226
33227   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33228   jresult = (int)result;
33229   return jresult;
33230 }
33231
33232
33233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33234   int jresult ;
33235   int result;
33236
33237   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33238   jresult = (int)result;
33239   return jresult;
33240 }
33241
33242
33243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33244   int jresult ;
33245   int result;
33246
33247   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33248   jresult = (int)result;
33249   return jresult;
33250 }
33251
33252
33253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33254   int jresult ;
33255   int result;
33256
33257   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33258   jresult = (int)result;
33259   return jresult;
33260 }
33261
33262
33263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33264   int jresult ;
33265   int result;
33266
33267   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33268   jresult = (int)result;
33269   return jresult;
33270 }
33271
33272
33273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33274   int jresult ;
33275   int result;
33276
33277   result = (int)Dali::Actor::Property::PADDING;
33278   jresult = (int)result;
33279   return jresult;
33280 }
33281
33282
33283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33284   int jresult ;
33285   int result;
33286
33287   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33288   jresult = (int)result;
33289   return jresult;
33290 }
33291
33292
33293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33294   int jresult ;
33295   int result;
33296
33297   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33298   jresult = (int)result;
33299   return jresult;
33300 }
33301
33302
33303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33304   int jresult ;
33305   int result;
33306
33307   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33308   jresult = (int)result;
33309   return jresult;
33310 }
33311
33312
33313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33314   int jresult ;
33315   int result;
33316
33317   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33318   jresult = (int)result;
33319   return jresult;
33320 }
33321
33322 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
33323
33324   return Dali::Actor::Property::OPACITY;
33325 }
33326
33327 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
33328
33329   return Dali::Actor::Property::SCREEN_POSITION;
33330 }
33331
33332 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
33333
33334   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
33335 }
33336
33337 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
33338   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
33339 }
33340
33341 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
33342   return Dali::Actor::Property::LAYOUT_DIRECTION;
33343 }
33344
33345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33346   void * jresult ;
33347   Dali::Actor::Property *result = 0 ;
33348
33349   {
33350     try {
33351       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33352     } catch (std::out_of_range& e) {
33353       {
33354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33355       };
33356     } catch (std::exception& e) {
33357       {
33358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33359       };
33360     } catch (Dali::DaliException e) {
33361       {
33362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33363       };
33364     } catch (...) {
33365       {
33366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33367       };
33368     }
33369   }
33370
33371   jresult = (void *)result;
33372   return jresult;
33373 }
33374
33375
33376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33377   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33378
33379   arg1 = (Dali::Actor::Property *)jarg1;
33380   {
33381     try {
33382       delete arg1;
33383     } catch (std::out_of_range& e) {
33384       {
33385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33386       };
33387     } catch (std::exception& e) {
33388       {
33389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33390       };
33391     } catch (Dali::DaliException e) {
33392       {
33393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33394       };
33395     } catch (...) {
33396       {
33397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33398       };
33399     }
33400   }
33401
33402 }
33403
33404
33405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33406   void * jresult ;
33407   Dali::Actor *result = 0 ;
33408
33409   {
33410     try {
33411       result = (Dali::Actor *)new Dali::Actor();
33412     } catch (std::out_of_range& e) {
33413       {
33414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33415       };
33416     } catch (std::exception& e) {
33417       {
33418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33419       };
33420     } catch (Dali::DaliException e) {
33421       {
33422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33423       };
33424     } catch (...) {
33425       {
33426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33427       };
33428     }
33429   }
33430
33431   jresult = (void *)result;
33432   return jresult;
33433 }
33434
33435
33436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33437   void * jresult ;
33438   Dali::Actor result;
33439
33440   {
33441     try {
33442       result = Dali::Actor::New();
33443     } catch (std::out_of_range& e) {
33444       {
33445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33446       };
33447     } catch (std::exception& e) {
33448       {
33449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33450       };
33451     } catch (Dali::DaliException e) {
33452       {
33453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33454       };
33455     } catch (...) {
33456       {
33457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33458       };
33459     }
33460   }
33461
33462   jresult = new Dali::Actor((const Dali::Actor &)result);
33463   return jresult;
33464 }
33465
33466
33467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33468   void * jresult ;
33469   Dali::BaseHandle arg1 ;
33470   Dali::BaseHandle *argp1 ;
33471   Dali::Actor result;
33472
33473   argp1 = (Dali::BaseHandle *)jarg1;
33474   if (!argp1) {
33475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33476     return 0;
33477   }
33478   arg1 = *argp1;
33479   {
33480     try {
33481       result = Dali::Actor::DownCast(arg1);
33482     } catch (std::out_of_range& e) {
33483       {
33484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33485       };
33486     } catch (std::exception& e) {
33487       {
33488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33489       };
33490     } catch (Dali::DaliException e) {
33491       {
33492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33493       };
33494     } catch (...) {
33495       {
33496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33497       };
33498     }
33499   }
33500
33501   jresult = new Dali::Actor((const Dali::Actor &)result);
33502   return jresult;
33503 }
33504
33505
33506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33507   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33508
33509   arg1 = (Dali::Actor *)jarg1;
33510   {
33511     try {
33512       delete arg1;
33513     } catch (std::out_of_range& e) {
33514       {
33515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33516       };
33517     } catch (std::exception& e) {
33518       {
33519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33520       };
33521     } catch (Dali::DaliException e) {
33522       {
33523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33524       };
33525     } catch (...) {
33526       {
33527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33528       };
33529     }
33530   }
33531
33532 }
33533
33534
33535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33536   void * jresult ;
33537   Dali::Actor *arg1 = 0 ;
33538   Dali::Actor *result = 0 ;
33539
33540   arg1 = (Dali::Actor *)jarg1;
33541   if (!arg1) {
33542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33543     return 0;
33544   }
33545   {
33546     try {
33547       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33548     } catch (std::out_of_range& e) {
33549       {
33550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33551       };
33552     } catch (std::exception& e) {
33553       {
33554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33555       };
33556     } catch (Dali::DaliException e) {
33557       {
33558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33559       };
33560     } catch (...) {
33561       {
33562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33563       };
33564     }
33565   }
33566
33567   jresult = (void *)result;
33568   return jresult;
33569 }
33570
33571
33572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33573   void * jresult ;
33574   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33575   Dali::Actor *arg2 = 0 ;
33576   Dali::Actor *result = 0 ;
33577
33578   arg1 = (Dali::Actor *)jarg1;
33579   arg2 = (Dali::Actor *)jarg2;
33580   if (!arg2) {
33581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33582     return 0;
33583   }
33584   {
33585     try {
33586       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33587     } catch (std::out_of_range& e) {
33588       {
33589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33590       };
33591     } catch (std::exception& e) {
33592       {
33593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33594       };
33595     } catch (Dali::DaliException e) {
33596       {
33597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33598       };
33599     } catch (...) {
33600       {
33601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33602       };
33603     }
33604   }
33605
33606   jresult = (void *)result;
33607   return jresult;
33608 }
33609
33610
33611 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33612   char * jresult ;
33613   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33614   std::string *result = 0 ;
33615
33616   arg1 = (Dali::Actor *)jarg1;
33617   {
33618     try {
33619       std::string name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
33620       result = (std::string *) &name;
33621     } catch (std::out_of_range& e) {
33622       {
33623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33624       };
33625     } catch (std::exception& e) {
33626       {
33627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33628       };
33629     } catch (Dali::DaliException e) {
33630       {
33631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33632       };
33633     } catch (...) {
33634       {
33635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33636       };
33637     }
33638   }
33639
33640   jresult = SWIG_csharp_string_callback(result->c_str());
33641   return jresult;
33642 }
33643
33644
33645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33646   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33647   std::string *arg2 = 0 ;
33648
33649   arg1 = (Dali::Actor *)jarg1;
33650   if (!jarg2) {
33651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33652     return ;
33653   }
33654   std::string arg2_str(jarg2);
33655   arg2 = &arg2_str;
33656   {
33657     try {
33658       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
33659     } catch (std::out_of_range& e) {
33660       {
33661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33662       };
33663     } catch (std::exception& e) {
33664       {
33665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33666       };
33667     } catch (Dali::DaliException e) {
33668       {
33669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33670       };
33671     } catch (...) {
33672       {
33673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33674       };
33675     }
33676   }
33677
33678
33679   //argout typemap for const std::string&
33680
33681 }
33682
33683
33684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33685   unsigned int jresult ;
33686   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33687   unsigned int result;
33688
33689   arg1 = (Dali::Actor *)jarg1;
33690
33691   if(!arg1) {
33692     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33693     return -1;
33694   }
33695
33696   {
33697     try {
33698       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
33699     } catch (std::out_of_range& e) {
33700       {
33701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33702       };
33703     } catch (std::exception& e) {
33704       {
33705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33706       };
33707     } catch (Dali::DaliException e) {
33708       {
33709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33710       };
33711     } catch (...) {
33712       {
33713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33714       };
33715     }
33716   }
33717
33718   jresult = result;
33719   return jresult;
33720 }
33721
33722
33723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33724   unsigned int jresult ;
33725   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33726   bool result;
33727
33728   arg1 = (Dali::Actor *)jarg1;
33729   {
33730     try {
33731       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
33732     } catch (std::out_of_range& e) {
33733       {
33734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33735       };
33736     } catch (std::exception& e) {
33737       {
33738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33739       };
33740     } catch (Dali::DaliException e) {
33741       {
33742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33743       };
33744     } catch (...) {
33745       {
33746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33747       };
33748     }
33749   }
33750
33751   jresult = result;
33752   return jresult;
33753 }
33754
33755
33756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33757   unsigned int jresult ;
33758   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33759   bool result;
33760
33761   arg1 = (Dali::Actor *)jarg1;
33762   {
33763     try {
33764       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
33765     } catch (std::out_of_range& e) {
33766       {
33767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33768       };
33769     } catch (std::exception& e) {
33770       {
33771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33772       };
33773     } catch (Dali::DaliException e) {
33774       {
33775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33776       };
33777     } catch (...) {
33778       {
33779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33780       };
33781     }
33782   }
33783
33784   jresult = result;
33785   return jresult;
33786 }
33787
33788
33789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33790   unsigned int jresult ;
33791   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33792   bool result;
33793
33794   arg1 = (Dali::Actor *)jarg1;
33795   {
33796     try {
33797       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
33798     } catch (std::out_of_range& e) {
33799       {
33800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33801       };
33802     } catch (std::exception& e) {
33803       {
33804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33805       };
33806     } catch (Dali::DaliException e) {
33807       {
33808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33809       };
33810     } catch (...) {
33811       {
33812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33813       };
33814     }
33815   }
33816
33817   jresult = result;
33818   return jresult;
33819 }
33820
33821
33822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33823   void * jresult ;
33824   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33825   Dali::Layer result;
33826
33827   arg1 = (Dali::Actor *)jarg1;
33828   {
33829     try {
33830       result = (arg1)->GetLayer();
33831     } catch (std::out_of_range& e) {
33832       {
33833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33834       };
33835     } catch (std::exception& e) {
33836       {
33837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33838       };
33839     } catch (Dali::DaliException e) {
33840       {
33841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33842       };
33843     } catch (...) {
33844       {
33845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33846       };
33847     }
33848   }
33849
33850   jresult = new Dali::Layer((const Dali::Layer &)result);
33851   return jresult;
33852 }
33853
33854
33855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33856   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33857   Dali::Actor arg2 ;
33858   Dali::Actor *argp2 ;
33859
33860   arg1 = (Dali::Actor *)jarg1;
33861   argp2 = (Dali::Actor *)jarg2;
33862   if (!argp2) {
33863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33864     return ;
33865   }
33866   arg2 = *argp2;
33867   {
33868     try {
33869       (arg1)->Add(arg2);
33870     } catch (std::out_of_range& e) {
33871       {
33872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33873       };
33874     } catch (std::exception& e) {
33875       {
33876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33877       };
33878     } catch (Dali::DaliException e) {
33879       {
33880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33881       };
33882     } catch (...) {
33883       {
33884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33885       };
33886     }
33887   }
33888
33889 }
33890
33891
33892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33893   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33894   Dali::Actor arg2 ;
33895   Dali::Actor *argp2 ;
33896
33897   arg1 = (Dali::Actor *)jarg1;
33898   argp2 = (Dali::Actor *)jarg2;
33899   if (!argp2) {
33900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33901     return ;
33902   }
33903   arg2 = *argp2;
33904   {
33905     try {
33906       (arg1)->Remove(arg2);
33907     } catch (std::out_of_range& e) {
33908       {
33909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33910       };
33911     } catch (std::exception& e) {
33912       {
33913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33914       };
33915     } catch (Dali::DaliException e) {
33916       {
33917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33918       };
33919     } catch (...) {
33920       {
33921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33922       };
33923     }
33924   }
33925
33926 }
33927
33928
33929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33930   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33931
33932   arg1 = (Dali::Actor *)jarg1;
33933   {
33934     try {
33935       (arg1)->Unparent();
33936     } catch (std::out_of_range& e) {
33937       {
33938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33939       };
33940     } catch (std::exception& e) {
33941       {
33942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33943       };
33944     } catch (Dali::DaliException e) {
33945       {
33946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33947       };
33948     } catch (...) {
33949       {
33950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33951       };
33952     }
33953   }
33954
33955 }
33956
33957
33958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33959   unsigned int jresult ;
33960   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33961   unsigned int result;
33962
33963   arg1 = (Dali::Actor *)jarg1;
33964   {
33965     try {
33966       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33967     } catch (std::out_of_range& e) {
33968       {
33969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33970       };
33971     } catch (std::exception& e) {
33972       {
33973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33974       };
33975     } catch (Dali::DaliException e) {
33976       {
33977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33978       };
33979     } catch (...) {
33980       {
33981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33982       };
33983     }
33984   }
33985
33986   jresult = result;
33987   return jresult;
33988 }
33989
33990
33991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
33992   void * jresult ;
33993   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33994   unsigned int arg2 ;
33995   Dali::Actor result;
33996
33997   arg1 = (Dali::Actor *)jarg1;
33998   arg2 = (unsigned int)jarg2;
33999   {
34000     try {
34001       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34002     } catch (std::out_of_range& e) {
34003       {
34004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34005       };
34006     } catch (std::exception& e) {
34007       {
34008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34009       };
34010     } catch (Dali::DaliException e) {
34011       {
34012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34013       };
34014     } catch (...) {
34015       {
34016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34017       };
34018     }
34019   }
34020
34021   jresult = new Dali::Actor((const Dali::Actor &)result);
34022   return jresult;
34023 }
34024
34025
34026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34027   void * jresult ;
34028   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34029   std::string *arg2 = 0 ;
34030   Dali::Actor result;
34031
34032   arg1 = (Dali::Actor *)jarg1;
34033   if (!jarg2) {
34034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34035     return 0;
34036   }
34037   std::string arg2_str(jarg2);
34038   arg2 = &arg2_str;
34039   {
34040     try {
34041       result = (arg1)->FindChildByName((std::string const &)*arg2);
34042     } catch (std::out_of_range& e) {
34043       {
34044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34045       };
34046     } catch (std::exception& e) {
34047       {
34048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34049       };
34050     } catch (Dali::DaliException e) {
34051       {
34052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34053       };
34054     } catch (...) {
34055       {
34056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34057       };
34058     }
34059   }
34060
34061   jresult = new Dali::Actor((const Dali::Actor &)result);
34062
34063   //argout typemap for const std::string&
34064
34065   return jresult;
34066 }
34067
34068
34069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34070   void * jresult ;
34071   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34072   unsigned int arg2 ;
34073   Dali::Actor result;
34074
34075   arg1 = (Dali::Actor *)jarg1;
34076   arg2 = (unsigned int)jarg2;
34077   {
34078     try {
34079       result = (arg1)->FindChildById(arg2);
34080     } catch (std::out_of_range& e) {
34081       {
34082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34083       };
34084     } catch (std::exception& e) {
34085       {
34086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34087       };
34088     } catch (Dali::DaliException e) {
34089       {
34090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34091       };
34092     } catch (...) {
34093       {
34094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34095       };
34096     }
34097   }
34098
34099   jresult = new Dali::Actor((const Dali::Actor &)result);
34100   return jresult;
34101 }
34102
34103
34104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34105   void * jresult ;
34106   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34107   Dali::Actor result;
34108
34109   arg1 = (Dali::Actor *)jarg1;
34110   {
34111     try {
34112       result = ((Dali::Actor const *)arg1)->GetParent();
34113     } catch (std::out_of_range& e) {
34114       {
34115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34116       };
34117     } catch (std::exception& e) {
34118       {
34119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34120       };
34121     } catch (Dali::DaliException e) {
34122       {
34123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34124       };
34125     } catch (...) {
34126       {
34127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34128       };
34129     }
34130   }
34131
34132   jresult = new Dali::Actor((const Dali::Actor &)result);
34133   return jresult;
34134 }
34135
34136
34137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34138   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34139   Dali::Vector3 *arg2 = 0 ;
34140
34141   arg1 = (Dali::Actor *)jarg1;
34142   arg2 = (Dali::Vector3 *)jarg2;
34143   if (!arg2) {
34144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34145     return ;
34146   }
34147   {
34148     try {
34149       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
34150     } catch (std::out_of_range& e) {
34151       {
34152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34153       };
34154     } catch (std::exception& e) {
34155       {
34156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34157       };
34158     } catch (Dali::DaliException e) {
34159       {
34160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34161       };
34162     } catch (...) {
34163       {
34164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34165       };
34166     }
34167   }
34168
34169 }
34170
34171
34172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34173   void * jresult ;
34174   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34175   Dali::Vector3 result;
34176
34177   arg1 = (Dali::Actor *)jarg1;
34178   {
34179     try {
34180       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
34181     } catch (std::out_of_range& e) {
34182       {
34183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34184       };
34185     } catch (std::exception& e) {
34186       {
34187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34188       };
34189     } catch (Dali::DaliException e) {
34190       {
34191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34192       };
34193     } catch (...) {
34194       {
34195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34196       };
34197     }
34198   }
34199
34200   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34201   return jresult;
34202 }
34203
34204
34205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34206   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34207   Dali::Vector3 *arg2 = 0 ;
34208
34209   arg1 = (Dali::Actor *)jarg1;
34210   arg2 = (Dali::Vector3 *)jarg2;
34211   if (!arg2) {
34212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34213     return ;
34214   }
34215   {
34216     try {
34217       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
34218     } catch (std::out_of_range& e) {
34219       {
34220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34221       };
34222     } catch (std::exception& e) {
34223       {
34224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34225       };
34226     } catch (Dali::DaliException e) {
34227       {
34228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34229       };
34230     } catch (...) {
34231       {
34232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34233       };
34234     }
34235   }
34236
34237 }
34238
34239
34240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34241   void * jresult ;
34242   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34243   Dali::Vector3 result;
34244
34245   arg1 = (Dali::Actor *)jarg1;
34246   {
34247     try {
34248       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
34249     } catch (std::out_of_range& e) {
34250       {
34251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34252       };
34253     } catch (std::exception& e) {
34254       {
34255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34256       };
34257     } catch (Dali::DaliException e) {
34258       {
34259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34260       };
34261     } catch (...) {
34262       {
34263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34264       };
34265     }
34266   }
34267
34268   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34269   return jresult;
34270 }
34271
34272
34273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34274   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34275   float arg2 ;
34276   float arg3 ;
34277
34278   arg1 = (Dali::Actor *)jarg1;
34279   arg2 = (float)jarg2;
34280   arg3 = (float)jarg3;
34281   {
34282     try {
34283       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
34284     } catch (std::out_of_range& e) {
34285       {
34286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34287       };
34288     } catch (std::exception& e) {
34289       {
34290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34291       };
34292     } catch (Dali::DaliException e) {
34293       {
34294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34295       };
34296     } catch (...) {
34297       {
34298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34299       };
34300     }
34301   }
34302
34303 }
34304
34305
34306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34307   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34308   float arg2 ;
34309   float arg3 ;
34310   float arg4 ;
34311
34312   arg1 = (Dali::Actor *)jarg1;
34313   arg2 = (float)jarg2;
34314   arg3 = (float)jarg3;
34315   arg4 = (float)jarg4;
34316   {
34317     try {
34318       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
34319     } catch (std::out_of_range& e) {
34320       {
34321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34322       };
34323     } catch (std::exception& e) {
34324       {
34325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34326       };
34327     } catch (Dali::DaliException e) {
34328       {
34329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34330       };
34331     } catch (...) {
34332       {
34333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34334       };
34335     }
34336   }
34337
34338 }
34339
34340
34341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34342   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34343   Dali::Vector2 *arg2 = 0 ;
34344
34345   arg1 = (Dali::Actor *)jarg1;
34346   arg2 = (Dali::Vector2 *)jarg2;
34347   if (!arg2) {
34348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34349     return ;
34350   }
34351   {
34352     try {
34353       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
34354     } catch (std::out_of_range& e) {
34355       {
34356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34357       };
34358     } catch (std::exception& e) {
34359       {
34360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34361       };
34362     } catch (Dali::DaliException e) {
34363       {
34364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34365       };
34366     } catch (...) {
34367       {
34368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34369       };
34370     }
34371   }
34372
34373 }
34374
34375
34376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34377   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34378   Dali::Vector3 *arg2 = 0 ;
34379
34380   arg1 = (Dali::Actor *)jarg1;
34381   arg2 = (Dali::Vector3 *)jarg2;
34382   if (!arg2) {
34383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34384     return ;
34385   }
34386   {
34387     try {
34388       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
34389     } catch (std::out_of_range& e) {
34390       {
34391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34392       };
34393     } catch (std::exception& e) {
34394       {
34395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34396       };
34397     } catch (Dali::DaliException e) {
34398       {
34399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34400       };
34401     } catch (...) {
34402       {
34403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34404       };
34405     }
34406   }
34407
34408 }
34409
34410
34411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34412   void * jresult ;
34413   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34414   Dali::Vector3 result;
34415
34416   arg1 = (Dali::Actor *)jarg1;
34417   {
34418     try {
34419       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34420     } catch (std::out_of_range& e) {
34421       {
34422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34423       };
34424     } catch (std::exception& e) {
34425       {
34426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34427       };
34428     } catch (Dali::DaliException e) {
34429       {
34430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34431       };
34432     } catch (...) {
34433       {
34434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34435       };
34436     }
34437   }
34438
34439   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34440   return jresult;
34441 }
34442
34443
34444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34445   void * jresult ;
34446   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34447   Dali::Vector3 result;
34448
34449   arg1 = (Dali::Actor *)jarg1;
34450   {
34451     try {
34452       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
34453     } catch (std::out_of_range& e) {
34454       {
34455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34456       };
34457     } catch (std::exception& e) {
34458       {
34459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34460       };
34461     } catch (Dali::DaliException e) {
34462       {
34463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34464       };
34465     } catch (...) {
34466       {
34467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34468       };
34469     }
34470   }
34471
34472   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34473   return jresult;
34474 }
34475
34476
34477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34478   void * jresult ;
34479   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34480   Dali::Vector3 result;
34481
34482   arg1 = (Dali::Actor *)jarg1;
34483   {
34484     try {
34485       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34486     } catch (std::out_of_range& e) {
34487       {
34488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34489       };
34490     } catch (std::exception& e) {
34491       {
34492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34493       };
34494     } catch (Dali::DaliException e) {
34495       {
34496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34497       };
34498     } catch (...) {
34499       {
34500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34501       };
34502     }
34503   }
34504
34505   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34506   return jresult;
34507 }
34508
34509
34510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34511   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34512   float arg2 ;
34513   float arg3 ;
34514
34515   arg1 = (Dali::Actor *)jarg1;
34516   arg2 = (float)jarg2;
34517   arg3 = (float)jarg3;
34518   {
34519     try {
34520       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
34521     } catch (std::out_of_range& e) {
34522       {
34523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34524       };
34525     } catch (std::exception& e) {
34526       {
34527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34528       };
34529     } catch (Dali::DaliException e) {
34530       {
34531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34532       };
34533     } catch (...) {
34534       {
34535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34536       };
34537     }
34538   }
34539
34540 }
34541
34542
34543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34544   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34545   float arg2 ;
34546   float arg3 ;
34547   float arg4 ;
34548
34549   arg1 = (Dali::Actor *)jarg1;
34550   arg2 = (float)jarg2;
34551   arg3 = (float)jarg3;
34552   arg4 = (float)jarg4;
34553   {
34554     try {
34555       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
34556     } catch (std::out_of_range& e) {
34557       {
34558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34559       };
34560     } catch (std::exception& e) {
34561       {
34562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34563       };
34564     } catch (Dali::DaliException e) {
34565       {
34566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34567       };
34568     } catch (...) {
34569       {
34570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34571       };
34572     }
34573   }
34574
34575 }
34576
34577
34578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34579   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34580   Dali::Vector3 *arg2 = 0 ;
34581
34582   arg1 = (Dali::Actor *)jarg1;
34583   arg2 = (Dali::Vector3 *)jarg2;
34584   if (!arg2) {
34585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34586     return ;
34587   }
34588   {
34589     try {
34590       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
34591     } catch (std::out_of_range& e) {
34592       {
34593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34594       };
34595     } catch (std::exception& e) {
34596       {
34597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34598       };
34599     } catch (Dali::DaliException e) {
34600       {
34601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34602       };
34603     } catch (...) {
34604       {
34605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34606       };
34607     }
34608   }
34609
34610 }
34611
34612
34613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34614   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34615   float arg2 ;
34616
34617   arg1 = (Dali::Actor *)jarg1;
34618   arg2 = (float)jarg2;
34619   {
34620     try {
34621       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
34622     } catch (std::out_of_range& e) {
34623       {
34624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34625       };
34626     } catch (std::exception& e) {
34627       {
34628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34629       };
34630     } catch (Dali::DaliException e) {
34631       {
34632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34633       };
34634     } catch (...) {
34635       {
34636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34637       };
34638     }
34639   }
34640
34641 }
34642
34643
34644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34645   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34646   float arg2 ;
34647
34648   arg1 = (Dali::Actor *)jarg1;
34649   arg2 = (float)jarg2;
34650   {
34651     try {
34652       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
34653     } catch (std::out_of_range& e) {
34654       {
34655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34656       };
34657     } catch (std::exception& e) {
34658       {
34659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34660       };
34661     } catch (Dali::DaliException e) {
34662       {
34663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34664       };
34665     } catch (...) {
34666       {
34667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34668       };
34669     }
34670   }
34671
34672 }
34673
34674
34675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34676   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34677   float arg2 ;
34678
34679   arg1 = (Dali::Actor *)jarg1;
34680   arg2 = (float)jarg2;
34681   {
34682     try {
34683       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
34684     } catch (std::out_of_range& e) {
34685       {
34686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34687       };
34688     } catch (std::exception& e) {
34689       {
34690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34691       };
34692     } catch (Dali::DaliException e) {
34693       {
34694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34695       };
34696     } catch (...) {
34697       {
34698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34699       };
34700     }
34701   }
34702
34703 }
34704
34705
34706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34707   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34708   Dali::Vector3 *arg2 = 0 ;
34709
34710   arg1 = (Dali::Actor *)jarg1;
34711   arg2 = (Dali::Vector3 *)jarg2;
34712   if (!arg2) {
34713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34714     return ;
34715   }
34716   {
34717     try {
34718       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34719     } catch (std::out_of_range& e) {
34720       {
34721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34722       };
34723     } catch (std::exception& e) {
34724       {
34725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34726       };
34727     } catch (Dali::DaliException e) {
34728       {
34729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34730       };
34731     } catch (...) {
34732       {
34733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34734       };
34735     }
34736   }
34737
34738 }
34739
34740
34741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34742   void * jresult ;
34743   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34744   Dali::Vector3 result;
34745
34746   arg1 = (Dali::Actor *)jarg1;
34747   {
34748     try {
34749       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
34750     } catch (std::out_of_range& e) {
34751       {
34752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34753       };
34754     } catch (std::exception& e) {
34755       {
34756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34757       };
34758     } catch (Dali::DaliException e) {
34759       {
34760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34761       };
34762     } catch (...) {
34763       {
34764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34765       };
34766     }
34767   }
34768
34769   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34770   return jresult;
34771 }
34772
34773
34774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34775   void * jresult ;
34776   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34777   Dali::Vector3 result;
34778
34779   arg1 = (Dali::Actor *)jarg1;
34780   {
34781     try {
34782       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
34783     } catch (std::out_of_range& e) {
34784       {
34785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34786       };
34787     } catch (std::exception& e) {
34788       {
34789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34790       };
34791     } catch (Dali::DaliException e) {
34792       {
34793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34794       };
34795     } catch (...) {
34796       {
34797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34798       };
34799     }
34800   }
34801
34802   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34803   return jresult;
34804 }
34805
34806
34807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34808   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34809   bool arg2 ;
34810
34811   arg1 = (Dali::Actor *)jarg1;
34812   arg2 = jarg2 ? true : false;
34813   {
34814     try {
34815       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
34816     } catch (std::out_of_range& e) {
34817       {
34818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34819       };
34820     } catch (std::exception& e) {
34821       {
34822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34823       };
34824     } catch (Dali::DaliException e) {
34825       {
34826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34827       };
34828     } catch (...) {
34829       {
34830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34831       };
34832     }
34833   }
34834
34835 }
34836
34837
34838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34839   unsigned int jresult ;
34840   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34841   bool result;
34842
34843   arg1 = (Dali::Actor *)jarg1;
34844   {
34845     try {
34846       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
34847     } catch (std::out_of_range& e) {
34848       {
34849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34850       };
34851     } catch (std::exception& e) {
34852       {
34853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34854       };
34855     } catch (Dali::DaliException e) {
34856       {
34857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34858       };
34859     } catch (...) {
34860       {
34861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34862       };
34863     }
34864   }
34865
34866   jresult = result;
34867   return jresult;
34868 }
34869
34870
34871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34872   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34873   Dali::Degree *arg2 = 0 ;
34874   Dali::Vector3 *arg3 = 0 ;
34875
34876   arg1 = (Dali::Actor *)jarg1;
34877   arg2 = (Dali::Degree *)jarg2;
34878   if (!arg2) {
34879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34880     return ;
34881   }
34882   arg3 = (Dali::Vector3 *)jarg3;
34883   if (!arg3) {
34884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34885     return ;
34886   }
34887   {
34888     try {
34889       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34890     } catch (std::out_of_range& e) {
34891       {
34892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34893       };
34894     } catch (std::exception& e) {
34895       {
34896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34897       };
34898     } catch (Dali::DaliException e) {
34899       {
34900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34901       };
34902     } catch (...) {
34903       {
34904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34905       };
34906     }
34907   }
34908
34909 }
34910
34911
34912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34913   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34914   Dali::Radian *arg2 = 0 ;
34915   Dali::Vector3 *arg3 = 0 ;
34916
34917   arg1 = (Dali::Actor *)jarg1;
34918   arg2 = (Dali::Radian *)jarg2;
34919   if (!arg2) {
34920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34921     return ;
34922   }
34923   arg3 = (Dali::Vector3 *)jarg3;
34924   if (!arg3) {
34925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34926     return ;
34927   }
34928   {
34929     try {
34930       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34931     } catch (std::out_of_range& e) {
34932       {
34933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34934       };
34935     } catch (std::exception& e) {
34936       {
34937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34938       };
34939     } catch (Dali::DaliException e) {
34940       {
34941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34942       };
34943     } catch (...) {
34944       {
34945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34946       };
34947     }
34948   }
34949
34950 }
34951
34952
34953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34954   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34955   Dali::Quaternion *arg2 = 0 ;
34956
34957   arg1 = (Dali::Actor *)jarg1;
34958   arg2 = (Dali::Quaternion *)jarg2;
34959   if (!arg2) {
34960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34961     return ;
34962   }
34963   {
34964     try {
34965       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
34966     } catch (std::out_of_range& e) {
34967       {
34968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34969       };
34970     } catch (std::exception& e) {
34971       {
34972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34973       };
34974     } catch (Dali::DaliException e) {
34975       {
34976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34977       };
34978     } catch (...) {
34979       {
34980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34981       };
34982     }
34983   }
34984
34985 }
34986
34987
34988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34989   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34990   Dali::Degree *arg2 = 0 ;
34991   Dali::Vector3 *arg3 = 0 ;
34992
34993   arg1 = (Dali::Actor *)jarg1;
34994   arg2 = (Dali::Degree *)jarg2;
34995   if (!arg2) {
34996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34997     return ;
34998   }
34999   arg3 = (Dali::Vector3 *)jarg3;
35000   if (!arg3) {
35001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35002     return ;
35003   }
35004   {
35005     try {
35006       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35007     } catch (std::out_of_range& e) {
35008       {
35009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35010       };
35011     } catch (std::exception& e) {
35012       {
35013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35014       };
35015     } catch (Dali::DaliException e) {
35016       {
35017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35018       };
35019     } catch (...) {
35020       {
35021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35022       };
35023     }
35024   }
35025
35026 }
35027
35028
35029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35030   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35031   Dali::Radian *arg2 = 0 ;
35032   Dali::Vector3 *arg3 = 0 ;
35033
35034   arg1 = (Dali::Actor *)jarg1;
35035   arg2 = (Dali::Radian *)jarg2;
35036   if (!arg2) {
35037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35038     return ;
35039   }
35040   arg3 = (Dali::Vector3 *)jarg3;
35041   if (!arg3) {
35042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35043     return ;
35044   }
35045   {
35046     try {
35047       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35048     } catch (std::out_of_range& e) {
35049       {
35050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35051       };
35052     } catch (std::exception& e) {
35053       {
35054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35055       };
35056     } catch (Dali::DaliException e) {
35057       {
35058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35059       };
35060     } catch (...) {
35061       {
35062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35063       };
35064     }
35065   }
35066
35067 }
35068
35069
35070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35071   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35072   Dali::Quaternion *arg2 = 0 ;
35073
35074   arg1 = (Dali::Actor *)jarg1;
35075   arg2 = (Dali::Quaternion *)jarg2;
35076   if (!arg2) {
35077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35078     return ;
35079   }
35080   {
35081     try {
35082       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35083     } catch (std::out_of_range& e) {
35084       {
35085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35086       };
35087     } catch (std::exception& e) {
35088       {
35089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35090       };
35091     } catch (Dali::DaliException e) {
35092       {
35093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35094       };
35095     } catch (...) {
35096       {
35097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35098       };
35099     }
35100   }
35101
35102 }
35103
35104
35105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35106   void * jresult ;
35107   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35108   Dali::Quaternion result;
35109
35110   arg1 = (Dali::Actor *)jarg1;
35111   {
35112     try {
35113       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
35114     } catch (std::out_of_range& e) {
35115       {
35116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35117       };
35118     } catch (std::exception& e) {
35119       {
35120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35121       };
35122     } catch (Dali::DaliException e) {
35123       {
35124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35125       };
35126     } catch (...) {
35127       {
35128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35129       };
35130     }
35131   }
35132
35133   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35134   return jresult;
35135 }
35136
35137
35138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35139   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35140   bool arg2 ;
35141
35142   arg1 = (Dali::Actor *)jarg1;
35143   arg2 = jarg2 ? true : false;
35144   {
35145     try {
35146       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
35147     } catch (std::out_of_range& e) {
35148       {
35149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35150       };
35151     } catch (std::exception& e) {
35152       {
35153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35154       };
35155     } catch (Dali::DaliException e) {
35156       {
35157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35158       };
35159     } catch (...) {
35160       {
35161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35162       };
35163     }
35164   }
35165
35166 }
35167
35168
35169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35170   unsigned int jresult ;
35171   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35172   bool result;
35173
35174   arg1 = (Dali::Actor *)jarg1;
35175   {
35176     try {
35177       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
35178     } catch (std::out_of_range& e) {
35179       {
35180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35181       };
35182     } catch (std::exception& e) {
35183       {
35184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35185       };
35186     } catch (Dali::DaliException e) {
35187       {
35188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35189       };
35190     } catch (...) {
35191       {
35192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35193       };
35194     }
35195   }
35196
35197   jresult = result;
35198   return jresult;
35199 }
35200
35201
35202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35203   void * jresult ;
35204   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35205   Dali::Quaternion result;
35206
35207   arg1 = (Dali::Actor *)jarg1;
35208   {
35209     try {
35210       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
35211     } catch (std::out_of_range& e) {
35212       {
35213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35214       };
35215     } catch (std::exception& e) {
35216       {
35217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35218       };
35219     } catch (Dali::DaliException e) {
35220       {
35221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35222       };
35223     } catch (...) {
35224       {
35225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35226       };
35227     }
35228   }
35229
35230   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35231   return jresult;
35232 }
35233
35234
35235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35236   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35237   float arg2 ;
35238
35239   arg1 = (Dali::Actor *)jarg1;
35240   arg2 = (float)jarg2;
35241   {
35242     try {
35243       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
35244     } catch (std::out_of_range& e) {
35245       {
35246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35247       };
35248     } catch (std::exception& e) {
35249       {
35250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35251       };
35252     } catch (Dali::DaliException e) {
35253       {
35254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35255       };
35256     } catch (...) {
35257       {
35258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35259       };
35260     }
35261   }
35262
35263 }
35264
35265
35266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35267   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35268   float arg2 ;
35269   float arg3 ;
35270   float arg4 ;
35271
35272   arg1 = (Dali::Actor *)jarg1;
35273   arg2 = (float)jarg2;
35274   arg3 = (float)jarg3;
35275   arg4 = (float)jarg4;
35276   {
35277     try {
35278       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
35279     } catch (std::out_of_range& e) {
35280       {
35281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35282       };
35283     } catch (std::exception& e) {
35284       {
35285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35286       };
35287     } catch (Dali::DaliException e) {
35288       {
35289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35290       };
35291     } catch (...) {
35292       {
35293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35294       };
35295     }
35296   }
35297
35298 }
35299
35300
35301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35302   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35303   Dali::Vector3 *arg2 = 0 ;
35304
35305   arg1 = (Dali::Actor *)jarg1;
35306   arg2 = (Dali::Vector3 *)jarg2;
35307   if (!arg2) {
35308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35309     return ;
35310   }
35311   {
35312     try {
35313       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
35314     } catch (std::out_of_range& e) {
35315       {
35316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35317       };
35318     } catch (std::exception& e) {
35319       {
35320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35321       };
35322     } catch (Dali::DaliException e) {
35323       {
35324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35325       };
35326     } catch (...) {
35327       {
35328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35329       };
35330     }
35331   }
35332
35333 }
35334
35335
35336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35337   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35338   Dali::Vector3 *arg2 = 0 ;
35339
35340   arg1 = (Dali::Actor *)jarg1;
35341   arg2 = (Dali::Vector3 *)jarg2;
35342   if (!arg2) {
35343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35344     return ;
35345   }
35346   {
35347     try {
35348       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35349     } catch (std::out_of_range& e) {
35350       {
35351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35352       };
35353     } catch (std::exception& e) {
35354       {
35355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35356       };
35357     } catch (Dali::DaliException e) {
35358       {
35359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35360       };
35361     } catch (...) {
35362       {
35363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35364       };
35365     }
35366   }
35367
35368 }
35369
35370
35371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35372   void * jresult ;
35373   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35374   Dali::Vector3 result;
35375
35376   arg1 = (Dali::Actor *)jarg1;
35377   {
35378     try {
35379       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
35380     } catch (std::out_of_range& e) {
35381       {
35382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35383       };
35384     } catch (std::exception& e) {
35385       {
35386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35387       };
35388     } catch (Dali::DaliException e) {
35389       {
35390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35391       };
35392     } catch (...) {
35393       {
35394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35395       };
35396     }
35397   }
35398
35399   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35400   return jresult;
35401 }
35402
35403
35404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35405   void * jresult ;
35406   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35407   Dali::Vector3 result;
35408
35409   arg1 = (Dali::Actor *)jarg1;
35410   {
35411     try {
35412       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
35413     } catch (std::out_of_range& e) {
35414       {
35415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35416       };
35417     } catch (std::exception& e) {
35418       {
35419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35420       };
35421     } catch (Dali::DaliException e) {
35422       {
35423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35424       };
35425     } catch (...) {
35426       {
35427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35428       };
35429     }
35430   }
35431
35432   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35433   return jresult;
35434 }
35435
35436
35437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35438   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35439   bool arg2 ;
35440
35441   arg1 = (Dali::Actor *)jarg1;
35442   arg2 = jarg2 ? true : false;
35443   {
35444     try {
35445       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
35446     } catch (std::out_of_range& e) {
35447       {
35448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35449       };
35450     } catch (std::exception& e) {
35451       {
35452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35453       };
35454     } catch (Dali::DaliException e) {
35455       {
35456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35457       };
35458     } catch (...) {
35459       {
35460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35461       };
35462     }
35463   }
35464
35465 }
35466
35467
35468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35469   unsigned int jresult ;
35470   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35471   bool result;
35472
35473   arg1 = (Dali::Actor *)jarg1;
35474   {
35475     try {
35476       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
35477     } catch (std::out_of_range& e) {
35478       {
35479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35480       };
35481     } catch (std::exception& e) {
35482       {
35483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35484       };
35485     } catch (Dali::DaliException e) {
35486       {
35487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35488       };
35489     } catch (...) {
35490       {
35491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35492       };
35493     }
35494   }
35495
35496   jresult = result;
35497   return jresult;
35498 }
35499
35500
35501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35502   void * jresult ;
35503   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35504   Dali::Matrix result;
35505
35506   arg1 = (Dali::Actor *)jarg1;
35507   {
35508     try {
35509       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
35510     } catch (std::out_of_range& e) {
35511       {
35512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35513       };
35514     } catch (std::exception& e) {
35515       {
35516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35517       };
35518     } catch (Dali::DaliException e) {
35519       {
35520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35521       };
35522     } catch (...) {
35523       {
35524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35525       };
35526     }
35527   }
35528
35529   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35530   return jresult;
35531 }
35532
35533
35534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35535   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35536   bool arg2 ;
35537
35538   arg1 = (Dali::Actor *)jarg1;
35539   arg2 = jarg2 ? true : false;
35540   {
35541     try {
35542       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
35543     } catch (std::out_of_range& e) {
35544       {
35545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35546       };
35547     } catch (std::exception& e) {
35548       {
35549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35550       };
35551     } catch (Dali::DaliException e) {
35552       {
35553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35554       };
35555     } catch (...) {
35556       {
35557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35558       };
35559     }
35560   }
35561
35562 }
35563
35564
35565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35566   unsigned int jresult ;
35567   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35568   bool result;
35569
35570   arg1 = (Dali::Actor *)jarg1;
35571   {
35572     try {
35573       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
35574     } catch (std::out_of_range& e) {
35575       {
35576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35577       };
35578     } catch (std::exception& e) {
35579       {
35580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35581       };
35582     } catch (Dali::DaliException e) {
35583       {
35584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35585       };
35586     } catch (...) {
35587       {
35588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35589       };
35590     }
35591   }
35592
35593   jresult = result;
35594   return jresult;
35595 }
35596
35597
35598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35599   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35600   float arg2 ;
35601
35602   arg1 = (Dali::Actor *)jarg1;
35603   arg2 = (float)jarg2;
35604   {
35605     try {
35606       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
35607     } catch (std::out_of_range& e) {
35608       {
35609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35610       };
35611     } catch (std::exception& e) {
35612       {
35613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35614       };
35615     } catch (Dali::DaliException e) {
35616       {
35617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35618       };
35619     } catch (...) {
35620       {
35621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35622       };
35623     }
35624   }
35625
35626 }
35627
35628
35629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35630   float jresult ;
35631   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35632   float result;
35633
35634   arg1 = (Dali::Actor *)jarg1;
35635   {
35636     try {
35637       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
35638     } catch (std::out_of_range& e) {
35639       {
35640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35641       };
35642     } catch (std::exception& e) {
35643       {
35644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35645       };
35646     } catch (Dali::DaliException e) {
35647       {
35648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35649       };
35650     } catch (...) {
35651       {
35652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35653       };
35654     }
35655   }
35656
35657   jresult = result;
35658   return jresult;
35659 }
35660
35661
35662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35663   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35664   Dali::Vector4 *arg2 = 0 ;
35665
35666   arg1 = (Dali::Actor *)jarg1;
35667   arg2 = (Dali::Vector4 *)jarg2;
35668   if (!arg2) {
35669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35670     return ;
35671   }
35672   {
35673     try {
35674       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
35675     } catch (std::out_of_range& e) {
35676       {
35677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35678       };
35679     } catch (std::exception& e) {
35680       {
35681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35682       };
35683     } catch (Dali::DaliException e) {
35684       {
35685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35686       };
35687     } catch (...) {
35688       {
35689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35690       };
35691     }
35692   }
35693
35694 }
35695
35696
35697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35698   void * jresult ;
35699   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35700   Dali::Vector4 result;
35701
35702   arg1 = (Dali::Actor *)jarg1;
35703   {
35704     try {
35705       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
35706     } catch (std::out_of_range& e) {
35707       {
35708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35709       };
35710     } catch (std::exception& e) {
35711       {
35712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35713       };
35714     } catch (Dali::DaliException e) {
35715       {
35716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35717       };
35718     } catch (...) {
35719       {
35720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35721       };
35722     }
35723   }
35724
35725   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35726   return jresult;
35727 }
35728
35729
35730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35731   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35732   Dali::ColorMode arg2 ;
35733
35734   arg1 = (Dali::Actor *)jarg1;
35735   arg2 = (Dali::ColorMode)jarg2;
35736   {
35737     try {
35738       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
35739     } catch (std::out_of_range& e) {
35740       {
35741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35742       };
35743     } catch (std::exception& e) {
35744       {
35745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35746       };
35747     } catch (Dali::DaliException e) {
35748       {
35749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35750       };
35751     } catch (...) {
35752       {
35753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35754       };
35755     }
35756   }
35757
35758 }
35759
35760
35761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35762   int jresult ;
35763   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35764   Dali::ColorMode result;
35765
35766   arg1 = (Dali::Actor *)jarg1;
35767   {
35768     try {
35769       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
35770     } catch (std::out_of_range& e) {
35771       {
35772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35773       };
35774     } catch (std::exception& e) {
35775       {
35776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35777       };
35778     } catch (Dali::DaliException e) {
35779       {
35780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35781       };
35782     } catch (...) {
35783       {
35784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35785       };
35786     }
35787   }
35788
35789   jresult = (int)result;
35790   return jresult;
35791 }
35792
35793
35794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35795   void * jresult ;
35796   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35797   Dali::Vector4 result;
35798
35799   arg1 = (Dali::Actor *)jarg1;
35800   {
35801     try {
35802       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
35803     } catch (std::out_of_range& e) {
35804       {
35805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35806       };
35807     } catch (std::exception& e) {
35808       {
35809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35810       };
35811     } catch (Dali::DaliException e) {
35812       {
35813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35814       };
35815     } catch (...) {
35816       {
35817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35818       };
35819     }
35820   }
35821
35822   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35823   return jresult;
35824 }
35825
35826
35827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35828   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35829   Dali::DrawMode::Type arg2 ;
35830
35831   arg1 = (Dali::Actor *)jarg1;
35832   arg2 = (Dali::DrawMode::Type)jarg2;
35833   {
35834     try {
35835       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
35836     } catch (std::out_of_range& e) {
35837       {
35838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35839       };
35840     } catch (std::exception& e) {
35841       {
35842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35843       };
35844     } catch (Dali::DaliException e) {
35845       {
35846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35847       };
35848     } catch (...) {
35849       {
35850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35851       };
35852     }
35853   }
35854
35855 }
35856
35857
35858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35859   int jresult ;
35860   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35861   Dali::DrawMode::Type result;
35862
35863   arg1 = (Dali::Actor *)jarg1;
35864   {
35865     try {
35866       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
35867     } catch (std::out_of_range& e) {
35868       {
35869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35870       };
35871     } catch (std::exception& e) {
35872       {
35873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35874       };
35875     } catch (Dali::DaliException e) {
35876       {
35877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35878       };
35879     } catch (...) {
35880       {
35881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35882       };
35883     }
35884   }
35885
35886   jresult = (int)result;
35887   return jresult;
35888 }
35889
35890
35891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35892   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35893   bool arg2 ;
35894
35895   arg1 = (Dali::Actor *)jarg1;
35896   arg2 = jarg2 ? true : false;
35897   {
35898     try {
35899       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
35900     } catch (std::out_of_range& e) {
35901       {
35902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35903       };
35904     } catch (std::exception& e) {
35905       {
35906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35907       };
35908     } catch (Dali::DaliException e) {
35909       {
35910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35911       };
35912     } catch (...) {
35913       {
35914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35915       };
35916     }
35917   }
35918
35919 }
35920
35921
35922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35923   unsigned int jresult ;
35924   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35925   bool result;
35926
35927   arg1 = (Dali::Actor *)jarg1;
35928   {
35929     try {
35930       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
35931     } catch (std::out_of_range& e) {
35932       {
35933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35934       };
35935     } catch (std::exception& e) {
35936       {
35937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35938       };
35939     } catch (Dali::DaliException e) {
35940       {
35941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35942       };
35943     } catch (...) {
35944       {
35945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35946       };
35947     }
35948   }
35949
35950   jresult = result;
35951   return jresult;
35952 }
35953
35954
35955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35956   unsigned int jresult ;
35957   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35958   float *arg2 = 0 ;
35959   float *arg3 = 0 ;
35960   float arg4 ;
35961   float arg5 ;
35962   bool result;
35963
35964   arg1 = (Dali::Actor *)jarg1;
35965   arg2 = (float *)jarg2;
35966   arg3 = (float *)jarg3;
35967   arg4 = (float)jarg4;
35968   arg5 = (float)jarg5;
35969   {
35970     try {
35971       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35972     } catch (std::out_of_range& e) {
35973       {
35974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35975       };
35976     } catch (std::exception& e) {
35977       {
35978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35979       };
35980     } catch (Dali::DaliException e) {
35981       {
35982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35983       };
35984     } catch (...) {
35985       {
35986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35987       };
35988     }
35989   }
35990
35991   jresult = result;
35992   return jresult;
35993 }
35994
35995
35996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
35997   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35998   bool arg2 ;
35999
36000   arg1 = (Dali::Actor *)jarg1;
36001   arg2 = jarg2 ? true : false;
36002   {
36003     try {
36004       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
36005     } catch (std::out_of_range& e) {
36006       {
36007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36008       };
36009     } catch (std::exception& e) {
36010       {
36011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36012       };
36013     } catch (Dali::DaliException e) {
36014       {
36015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36016       };
36017     } catch (...) {
36018       {
36019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36020       };
36021     }
36022   }
36023
36024 }
36025
36026
36027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36028   unsigned int jresult ;
36029   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36030   bool result;
36031
36032   arg1 = (Dali::Actor *)jarg1;
36033   {
36034     try {
36035       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
36036     } catch (std::out_of_range& e) {
36037       {
36038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36039       };
36040     } catch (std::exception& e) {
36041       {
36042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36043       };
36044     } catch (Dali::DaliException e) {
36045       {
36046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36047       };
36048     } catch (...) {
36049       {
36050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36051       };
36052     }
36053   }
36054
36055   jresult = result;
36056   return jresult;
36057 }
36058
36059
36060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36061   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36062   bool arg2 ;
36063
36064   arg1 = (Dali::Actor *)jarg1;
36065   arg2 = jarg2 ? true : false;
36066   {
36067     try {
36068       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
36069     } catch (std::out_of_range& e) {
36070       {
36071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36072       };
36073     } catch (std::exception& e) {
36074       {
36075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36076       };
36077     } catch (Dali::DaliException e) {
36078       {
36079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36080       };
36081     } catch (...) {
36082       {
36083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36084       };
36085     }
36086   }
36087
36088 }
36089
36090
36091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36092   unsigned int jresult ;
36093   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36094   bool result;
36095
36096   arg1 = (Dali::Actor *)jarg1;
36097   {
36098     try {
36099       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
36100     } catch (std::out_of_range& e) {
36101       {
36102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36103       };
36104     } catch (std::exception& e) {
36105       {
36106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36107       };
36108     } catch (Dali::DaliException e) {
36109       {
36110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36111       };
36112     } catch (...) {
36113       {
36114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36115       };
36116     }
36117   }
36118
36119   jresult = result;
36120   return jresult;
36121 }
36122
36123
36124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36125   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36126   Dali::ResizePolicy::Type arg2 ;
36127   Dali::Dimension::Type arg3 ;
36128
36129   arg1 = (Dali::Actor *)jarg1;
36130   arg2 = (Dali::ResizePolicy::Type)jarg2;
36131   arg3 = (Dali::Dimension::Type)jarg3;
36132   {
36133     try {
36134       (arg1)->SetResizePolicy(arg2,arg3);
36135     } catch (std::out_of_range& e) {
36136       {
36137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36138       };
36139     } catch (std::exception& e) {
36140       {
36141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36142       };
36143     } catch (Dali::DaliException e) {
36144       {
36145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36146       };
36147     } catch (...) {
36148       {
36149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36150       };
36151     }
36152   }
36153
36154 }
36155
36156
36157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36158   int jresult ;
36159   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36160   Dali::Dimension::Type arg2 ;
36161   Dali::ResizePolicy::Type result;
36162
36163   arg1 = (Dali::Actor *)jarg1;
36164   arg2 = (Dali::Dimension::Type)jarg2;
36165   {
36166     try {
36167       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36168     } catch (std::out_of_range& e) {
36169       {
36170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36171       };
36172     } catch (std::exception& e) {
36173       {
36174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36175       };
36176     } catch (Dali::DaliException e) {
36177       {
36178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36179       };
36180     } catch (...) {
36181       {
36182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36183       };
36184     }
36185   }
36186
36187   jresult = (int)result;
36188   return jresult;
36189 }
36190
36191
36192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36193   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36194   Dali::SizeScalePolicy::Type arg2 ;
36195
36196   arg1 = (Dali::Actor *)jarg1;
36197   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36198   {
36199     try {
36200       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
36201     } catch (std::out_of_range& e) {
36202       {
36203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36204       };
36205     } catch (std::exception& e) {
36206       {
36207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36208       };
36209     } catch (Dali::DaliException e) {
36210       {
36211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36212       };
36213     } catch (...) {
36214       {
36215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36216       };
36217     }
36218   }
36219
36220 }
36221
36222
36223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36224   int jresult ;
36225   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36226   Dali::SizeScalePolicy::Type result;
36227
36228   arg1 = (Dali::Actor *)jarg1;
36229   {
36230     try {
36231       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
36232     } catch (std::out_of_range& e) {
36233       {
36234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36235       };
36236     } catch (std::exception& e) {
36237       {
36238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36239       };
36240     } catch (Dali::DaliException e) {
36241       {
36242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36243       };
36244     } catch (...) {
36245       {
36246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36247       };
36248     }
36249   }
36250
36251   jresult = (int)result;
36252   return jresult;
36253 }
36254
36255
36256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36257   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36258   Dali::Vector3 *arg2 = 0 ;
36259
36260   arg1 = (Dali::Actor *)jarg1;
36261   arg2 = (Dali::Vector3 *)jarg2;
36262   if (!arg2) {
36263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36264     return ;
36265   }
36266   {
36267     try {
36268       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
36269     } catch (std::out_of_range& e) {
36270       {
36271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36272       };
36273     } catch (std::exception& e) {
36274       {
36275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36276       };
36277     } catch (Dali::DaliException e) {
36278       {
36279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36280       };
36281     } catch (...) {
36282       {
36283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36284       };
36285     }
36286   }
36287
36288 }
36289
36290
36291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36292   void * jresult ;
36293   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36294   Dali::Vector3 result;
36295
36296   arg1 = (Dali::Actor *)jarg1;
36297   {
36298     try {
36299       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
36300     } catch (std::out_of_range& e) {
36301       {
36302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36303       };
36304     } catch (std::exception& e) {
36305       {
36306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36307       };
36308     } catch (Dali::DaliException e) {
36309       {
36310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36311       };
36312     } catch (...) {
36313       {
36314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36315       };
36316     }
36317   }
36318
36319   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36320   return jresult;
36321 }
36322
36323
36324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36325   float jresult ;
36326   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36327   float arg2 ;
36328   float result;
36329
36330   arg1 = (Dali::Actor *)jarg1;
36331   arg2 = (float)jarg2;
36332   {
36333     try {
36334       result = (float)(arg1)->GetHeightForWidth(arg2);
36335     } catch (std::out_of_range& e) {
36336       {
36337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36338       };
36339     } catch (std::exception& e) {
36340       {
36341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36342       };
36343     } catch (Dali::DaliException e) {
36344       {
36345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36346       };
36347     } catch (...) {
36348       {
36349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36350       };
36351     }
36352   }
36353
36354   jresult = result;
36355   return jresult;
36356 }
36357
36358
36359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36360   float jresult ;
36361   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36362   float arg2 ;
36363   float result;
36364
36365   arg1 = (Dali::Actor *)jarg1;
36366   arg2 = (float)jarg2;
36367   {
36368     try {
36369       result = (float)(arg1)->GetWidthForHeight(arg2);
36370     } catch (std::out_of_range& e) {
36371       {
36372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36373       };
36374     } catch (std::exception& e) {
36375       {
36376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36377       };
36378     } catch (Dali::DaliException e) {
36379       {
36380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36381       };
36382     } catch (...) {
36383       {
36384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36385       };
36386     }
36387   }
36388
36389   jresult = result;
36390   return jresult;
36391 }
36392
36393
36394 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36395   float jresult ;
36396   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36397   Dali::Dimension::Type arg2 ;
36398   float result;
36399
36400   arg1 = (Dali::Actor *)jarg1;
36401   arg2 = (Dali::Dimension::Type)jarg2;
36402   {
36403     try {
36404       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36405     } catch (std::out_of_range& e) {
36406       {
36407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36408       };
36409     } catch (std::exception& e) {
36410       {
36411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36412       };
36413     } catch (Dali::DaliException e) {
36414       {
36415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36416       };
36417     } catch (...) {
36418       {
36419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36420       };
36421     }
36422   }
36423
36424   jresult = result;
36425   return jresult;
36426 }
36427
36428
36429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36430   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36431   Dali::Padding *arg2 = 0 ;
36432
36433   arg1 = (Dali::Actor *)jarg1;
36434   arg2 = (Dali::Padding *)jarg2;
36435   if (!arg2) {
36436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36437     return ;
36438   }
36439   {
36440     try {
36441       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
36442     } catch (std::out_of_range& e) {
36443       {
36444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36445       };
36446     } catch (std::exception& e) {
36447       {
36448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36449       };
36450     } catch (Dali::DaliException e) {
36451       {
36452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36453       };
36454     } catch (...) {
36455       {
36456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36457       };
36458     }
36459   }
36460
36461 }
36462
36463
36464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36465   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36466   Dali::Padding *arg2 = 0 ;
36467
36468   arg1 = (Dali::Actor *)jarg1;
36469   arg2 = (Dali::Padding *)jarg2;
36470   if (!arg2) {
36471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36472     return ;
36473   }
36474   {
36475     try {
36476       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
36477     } catch (std::out_of_range& e) {
36478       {
36479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36480       };
36481     } catch (std::exception& e) {
36482       {
36483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36484       };
36485     } catch (Dali::DaliException e) {
36486       {
36487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36488       };
36489     } catch (...) {
36490       {
36491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36492       };
36493     }
36494   }
36495
36496 }
36497
36498
36499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36500   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36501   Dali::Vector2 *arg2 = 0 ;
36502
36503   arg1 = (Dali::Actor *)jarg1;
36504   arg2 = (Dali::Vector2 *)jarg2;
36505   if (!arg2) {
36506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36507     return ;
36508   }
36509   {
36510     try {
36511       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36512     } catch (std::out_of_range& e) {
36513       {
36514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36515       };
36516     } catch (std::exception& e) {
36517       {
36518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36519       };
36520     } catch (Dali::DaliException e) {
36521       {
36522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36523       };
36524     } catch (...) {
36525       {
36526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36527       };
36528     }
36529   }
36530
36531 }
36532
36533
36534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36535   void * jresult ;
36536   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36537   Dali::Vector2 result;
36538
36539   arg1 = (Dali::Actor *)jarg1;
36540   {
36541     try {
36542       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
36543     } catch (std::out_of_range& e) {
36544       {
36545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36546       };
36547     } catch (std::exception& e) {
36548       {
36549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36550       };
36551     } catch (Dali::DaliException e) {
36552       {
36553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36554       };
36555     } catch (...) {
36556       {
36557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36558       };
36559     }
36560   }
36561
36562   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36563   return jresult;
36564 }
36565
36566
36567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36568   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36569   Dali::Vector2 *arg2 = 0 ;
36570
36571   arg1 = (Dali::Actor *)jarg1;
36572   arg2 = (Dali::Vector2 *)jarg2;
36573   if (!arg2) {
36574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36575     return ;
36576   }
36577   {
36578     try {
36579       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36580     } catch (std::out_of_range& e) {
36581       {
36582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36583       };
36584     } catch (std::exception& e) {
36585       {
36586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36587       };
36588     } catch (Dali::DaliException e) {
36589       {
36590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36591       };
36592     } catch (...) {
36593       {
36594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36595       };
36596     }
36597   }
36598
36599 }
36600
36601
36602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36603   void * jresult ;
36604   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36605   Dali::Vector2 result;
36606
36607   arg1 = (Dali::Actor *)jarg1;
36608   {
36609     try {
36610       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
36611     } catch (std::out_of_range& e) {
36612       {
36613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36614       };
36615     } catch (std::exception& e) {
36616       {
36617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36618       };
36619     } catch (Dali::DaliException e) {
36620       {
36621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36622       };
36623     } catch (...) {
36624       {
36625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36626       };
36627     }
36628   }
36629
36630   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36631   return jresult;
36632 }
36633
36634
36635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36636   int jresult ;
36637   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36638   int result;
36639
36640   arg1 = (Dali::Actor *)jarg1;
36641   {
36642     try {
36643       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
36644       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36645     } catch (std::out_of_range& e) {
36646       {
36647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36648       };
36649     } catch (std::exception& e) {
36650       {
36651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36652       };
36653     } catch (Dali::DaliException e) {
36654       {
36655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36656       };
36657     } catch (...) {
36658       {
36659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36660       };
36661     }
36662   }
36663
36664   jresult = result;
36665   return jresult;
36666 }
36667
36668
36669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36670   unsigned int jresult ;
36671   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36672   Dali::Renderer *arg2 = 0 ;
36673   unsigned int result;
36674
36675   arg1 = (Dali::Actor *)jarg1;
36676   arg2 = (Dali::Renderer *)jarg2;
36677   if (!arg2) {
36678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36679     return 0;
36680   }
36681   {
36682     try {
36683       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36684     } catch (std::out_of_range& e) {
36685       {
36686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36687       };
36688     } catch (std::exception& e) {
36689       {
36690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36691       };
36692     } catch (Dali::DaliException e) {
36693       {
36694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36695       };
36696     } catch (...) {
36697       {
36698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36699       };
36700     }
36701   }
36702
36703   jresult = result;
36704   return jresult;
36705 }
36706
36707
36708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36709   unsigned int jresult ;
36710   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36711   unsigned int result;
36712
36713   arg1 = (Dali::Actor *)jarg1;
36714   {
36715     try {
36716       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36717     } catch (std::out_of_range& e) {
36718       {
36719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36720       };
36721     } catch (std::exception& e) {
36722       {
36723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36724       };
36725     } catch (Dali::DaliException e) {
36726       {
36727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36728       };
36729     } catch (...) {
36730       {
36731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36732       };
36733     }
36734   }
36735
36736   jresult = result;
36737   return jresult;
36738 }
36739
36740
36741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36742   void * jresult ;
36743   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36744   unsigned int arg2 ;
36745   Dali::Renderer result;
36746
36747   arg1 = (Dali::Actor *)jarg1;
36748   arg2 = (unsigned int)jarg2;
36749   {
36750     try {
36751       result = (arg1)->GetRendererAt(arg2);
36752     } catch (std::out_of_range& e) {
36753       {
36754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36755       };
36756     } catch (std::exception& e) {
36757       {
36758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36759       };
36760     } catch (Dali::DaliException e) {
36761       {
36762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36763       };
36764     } catch (...) {
36765       {
36766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36767       };
36768     }
36769   }
36770
36771   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36772   return jresult;
36773 }
36774
36775
36776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36777   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36778   Dali::Renderer *arg2 = 0 ;
36779
36780   arg1 = (Dali::Actor *)jarg1;
36781   arg2 = (Dali::Renderer *)jarg2;
36782   if (!arg2) {
36783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36784     return ;
36785   }
36786   {
36787     try {
36788       (arg1)->RemoveRenderer(*arg2);
36789     } catch (std::out_of_range& e) {
36790       {
36791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36792       };
36793     } catch (std::exception& e) {
36794       {
36795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36796       };
36797     } catch (Dali::DaliException e) {
36798       {
36799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36800       };
36801     } catch (...) {
36802       {
36803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36804       };
36805     }
36806   }
36807
36808 }
36809
36810
36811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36812   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36813   unsigned int arg2 ;
36814
36815   arg1 = (Dali::Actor *)jarg1;
36816   arg2 = (unsigned int)jarg2;
36817   {
36818     try {
36819       (arg1)->RemoveRenderer(arg2);
36820     } catch (std::out_of_range& e) {
36821       {
36822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36823       };
36824     } catch (std::exception& e) {
36825       {
36826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36827       };
36828     } catch (Dali::DaliException e) {
36829       {
36830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36831       };
36832     } catch (...) {
36833       {
36834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36835       };
36836     }
36837   }
36838
36839 }
36840
36841
36842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36843   void * jresult ;
36844   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36845   Dali::Actor::TouchEventSignalType *result = 0 ;
36846
36847   arg1 = (Dali::Actor *)jarg1;
36848   {
36849     try {
36850       result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchSignal();
36851     } catch (std::out_of_range& e) {
36852       {
36853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36854       };
36855     } catch (std::exception& e) {
36856       {
36857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36858       };
36859     } catch (Dali::DaliException e) {
36860       {
36861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36862       };
36863     } catch (...) {
36864       {
36865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36866       };
36867     }
36868   }
36869
36870   jresult = (void *)result;
36871   return jresult;
36872 }
36873
36874
36875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36876   void * jresult ;
36877   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36878   Dali::Actor::HoverSignalType *result = 0 ;
36879
36880   arg1 = (Dali::Actor *)jarg1;
36881   {
36882     try {
36883       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36884     } catch (std::out_of_range& e) {
36885       {
36886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36887       };
36888     } catch (std::exception& e) {
36889       {
36890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36891       };
36892     } catch (Dali::DaliException e) {
36893       {
36894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36895       };
36896     } catch (...) {
36897       {
36898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36899       };
36900     }
36901   }
36902
36903   jresult = (void *)result;
36904   return jresult;
36905 }
36906
36907
36908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36909   void * jresult ;
36910   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36911   Dali::Actor::WheelEventSignalType *result = 0 ;
36912
36913   arg1 = (Dali::Actor *)jarg1;
36914   {
36915     try {
36916       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36917     } catch (std::out_of_range& e) {
36918       {
36919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36920       };
36921     } catch (std::exception& e) {
36922       {
36923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36924       };
36925     } catch (Dali::DaliException e) {
36926       {
36927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36928       };
36929     } catch (...) {
36930       {
36931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36932       };
36933     }
36934   }
36935
36936   jresult = (void *)result;
36937   return jresult;
36938 }
36939
36940
36941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
36942   void * jresult ;
36943   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36944   Dali::Actor::OnSceneSignalType *result = 0 ;
36945
36946   arg1 = (Dali::Actor *)jarg1;
36947   {
36948     try {
36949       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
36950     } catch (std::out_of_range& e) {
36951       {
36952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36953       };
36954     } catch (std::exception& e) {
36955       {
36956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36957       };
36958     } catch (Dali::DaliException e) {
36959       {
36960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36961       };
36962     } catch (...) {
36963       {
36964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36965       };
36966     }
36967   }
36968
36969   jresult = (void *)result;
36970   return jresult;
36971 }
36972
36973
36974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
36975   void * jresult ;
36976   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36977   Dali::Actor::OffSceneSignalType *result = 0 ;
36978
36979   arg1 = (Dali::Actor *)jarg1;
36980   {
36981     try {
36982       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
36983     } catch (std::out_of_range& e) {
36984       {
36985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36986       };
36987     } catch (std::exception& e) {
36988       {
36989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36990       };
36991     } catch (Dali::DaliException e) {
36992       {
36993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36994       };
36995     } catch (...) {
36996       {
36997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36998       };
36999     }
37000   }
37001
37002   jresult = (void *)result;
37003   return jresult;
37004 }
37005
37006
37007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37008   void * jresult ;
37009   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37010   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37011
37012   arg1 = (Dali::Actor *)jarg1;
37013   {
37014     try {
37015       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37016     } catch (std::out_of_range& e) {
37017       {
37018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37019       };
37020     } catch (std::exception& e) {
37021       {
37022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37023       };
37024     } catch (Dali::DaliException e) {
37025       {
37026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37027       };
37028     } catch (...) {
37029       {
37030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37031       };
37032     }
37033   }
37034
37035   jresult = (void *)result;
37036   return jresult;
37037 }
37038
37039
37040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37041   Dali::Actor *arg1 = 0 ;
37042
37043   arg1 = (Dali::Actor *)jarg1;
37044   if (!arg1) {
37045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37046     return ;
37047   }
37048   {
37049     try {
37050       Dali::UnparentAndReset(*arg1);
37051     } catch (std::out_of_range& e) {
37052       {
37053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37054       };
37055     } catch (std::exception& e) {
37056       {
37057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37058       };
37059     } catch (Dali::DaliException e) {
37060       {
37061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37062       };
37063     } catch (...) {
37064       {
37065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37066       };
37067     }
37068   }
37069
37070 }
37071
37072
37073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37074   int jresult ;
37075   int result;
37076
37077   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37078   jresult = (int)result;
37079   return jresult;
37080 }
37081
37082
37083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37084   int jresult ;
37085   int result;
37086
37087   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37088   jresult = (int)result;
37089   return jresult;
37090 }
37091
37092
37093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37094   int jresult ;
37095   int result;
37096
37097   result = (int)Dali::Layer::Property::BEHAVIOR;
37098   jresult = (int)result;
37099   return jresult;
37100 }
37101
37102
37103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37104   void * jresult ;
37105   Dali::Layer::Property *result = 0 ;
37106
37107   {
37108     try {
37109       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37110     } catch (std::out_of_range& e) {
37111       {
37112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37113       };
37114     } catch (std::exception& e) {
37115       {
37116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37117       };
37118     } catch (Dali::DaliException e) {
37119       {
37120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37121       };
37122     } catch (...) {
37123       {
37124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37125       };
37126     }
37127   }
37128
37129   jresult = (void *)result;
37130   return jresult;
37131 }
37132
37133
37134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37135   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37136
37137   arg1 = (Dali::Layer::Property *)jarg1;
37138   {
37139     try {
37140       delete arg1;
37141     } catch (std::out_of_range& e) {
37142       {
37143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37144       };
37145     } catch (std::exception& e) {
37146       {
37147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37148       };
37149     } catch (Dali::DaliException e) {
37150       {
37151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37152       };
37153     } catch (...) {
37154       {
37155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37156       };
37157     }
37158   }
37159
37160 }
37161
37162
37163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37164   void * jresult ;
37165   Dali::Layer *result = 0 ;
37166
37167   {
37168     try {
37169       result = (Dali::Layer *)new Dali::Layer();
37170     } catch (std::out_of_range& e) {
37171       {
37172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37173       };
37174     } catch (std::exception& e) {
37175       {
37176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37177       };
37178     } catch (Dali::DaliException e) {
37179       {
37180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37181       };
37182     } catch (...) {
37183       {
37184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37185       };
37186     }
37187   }
37188
37189   jresult = (void *)result;
37190   return jresult;
37191 }
37192
37193
37194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37195   void * jresult ;
37196   Dali::Layer result;
37197
37198   {
37199     try {
37200       result = Dali::Layer::New();
37201     } catch (std::out_of_range& e) {
37202       {
37203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37204       };
37205     } catch (std::exception& e) {
37206       {
37207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37208       };
37209     } catch (Dali::DaliException e) {
37210       {
37211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37212       };
37213     } catch (...) {
37214       {
37215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37216       };
37217     }
37218   }
37219
37220   jresult = new Dali::Layer((const Dali::Layer &)result);
37221   return jresult;
37222 }
37223
37224
37225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37226   void * jresult ;
37227   Dali::BaseHandle arg1 ;
37228   Dali::BaseHandle *argp1 ;
37229   Dali::Layer result;
37230
37231   argp1 = (Dali::BaseHandle *)jarg1;
37232   if (!argp1) {
37233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37234     return 0;
37235   }
37236   arg1 = *argp1;
37237   {
37238     try {
37239       result = Dali::Layer::DownCast(arg1);
37240     } catch (std::out_of_range& e) {
37241       {
37242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37243       };
37244     } catch (std::exception& e) {
37245       {
37246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37247       };
37248     } catch (Dali::DaliException e) {
37249       {
37250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37251       };
37252     } catch (...) {
37253       {
37254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37255       };
37256     }
37257   }
37258
37259   jresult = new Dali::Layer((const Dali::Layer &)result);
37260   return jresult;
37261 }
37262
37263
37264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37265   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37266
37267   arg1 = (Dali::Layer *)jarg1;
37268   {
37269     try {
37270       delete arg1;
37271     } catch (std::out_of_range& e) {
37272       {
37273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37274       };
37275     } catch (std::exception& e) {
37276       {
37277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37278       };
37279     } catch (Dali::DaliException e) {
37280       {
37281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37282       };
37283     } catch (...) {
37284       {
37285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37286       };
37287     }
37288   }
37289
37290 }
37291
37292
37293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37294   void * jresult ;
37295   Dali::Layer *arg1 = 0 ;
37296   Dali::Layer *result = 0 ;
37297
37298   arg1 = (Dali::Layer *)jarg1;
37299   if (!arg1) {
37300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37301     return 0;
37302   }
37303   {
37304     try {
37305       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37306     } catch (std::out_of_range& e) {
37307       {
37308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37309       };
37310     } catch (std::exception& e) {
37311       {
37312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37313       };
37314     } catch (Dali::DaliException e) {
37315       {
37316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37317       };
37318     } catch (...) {
37319       {
37320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37321       };
37322     }
37323   }
37324
37325   jresult = (void *)result;
37326   return jresult;
37327 }
37328
37329
37330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37331   void * jresult ;
37332   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37333   Dali::Layer *arg2 = 0 ;
37334   Dali::Layer *result = 0 ;
37335
37336   arg1 = (Dali::Layer *)jarg1;
37337   arg2 = (Dali::Layer *)jarg2;
37338   if (!arg2) {
37339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37340     return 0;
37341   }
37342   {
37343     try {
37344       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37345     } catch (std::out_of_range& e) {
37346       {
37347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37348       };
37349     } catch (std::exception& e) {
37350       {
37351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37352       };
37353     } catch (Dali::DaliException e) {
37354       {
37355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37356       };
37357     } catch (...) {
37358       {
37359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37360       };
37361     }
37362   }
37363
37364   jresult = (void *)result;
37365   return jresult;
37366 }
37367
37368
37369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37370   unsigned int jresult ;
37371   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37372   unsigned int result;
37373
37374   arg1 = (Dali::Layer *)jarg1;
37375   {
37376     try {
37377       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
37378     } catch (std::out_of_range& e) {
37379       {
37380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37381       };
37382     } catch (std::exception& e) {
37383       {
37384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37385       };
37386     } catch (Dali::DaliException e) {
37387       {
37388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37389       };
37390     } catch (...) {
37391       {
37392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37393       };
37394     }
37395   }
37396
37397   jresult = result;
37398   return jresult;
37399 }
37400
37401
37402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37403   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37404
37405   arg1 = (Dali::Layer *)jarg1;
37406   {
37407     try {
37408       (arg1)->Raise();
37409     } catch (std::out_of_range& e) {
37410       {
37411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37412       };
37413     } catch (std::exception& e) {
37414       {
37415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37416       };
37417     } catch (Dali::DaliException e) {
37418       {
37419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37420       };
37421     } catch (...) {
37422       {
37423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37424       };
37425     }
37426   }
37427
37428 }
37429
37430
37431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37432   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37433
37434   arg1 = (Dali::Layer *)jarg1;
37435   {
37436     try {
37437       (arg1)->Lower();
37438     } catch (std::out_of_range& e) {
37439       {
37440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37441       };
37442     } catch (std::exception& e) {
37443       {
37444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37445       };
37446     } catch (Dali::DaliException e) {
37447       {
37448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37449       };
37450     } catch (...) {
37451       {
37452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37453       };
37454     }
37455   }
37456
37457 }
37458
37459
37460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37461   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37462   Dali::Layer arg2 ;
37463   Dali::Layer *argp2 ;
37464
37465   arg1 = (Dali::Layer *)jarg1;
37466   argp2 = (Dali::Layer *)jarg2;
37467   if (!argp2) {
37468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37469     return ;
37470   }
37471   arg2 = *argp2;
37472   {
37473     try {
37474       (arg1)->RaiseAbove(arg2);
37475     } catch (std::out_of_range& e) {
37476       {
37477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37478       };
37479     } catch (std::exception& e) {
37480       {
37481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37482       };
37483     } catch (Dali::DaliException e) {
37484       {
37485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37486       };
37487     } catch (...) {
37488       {
37489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37490       };
37491     }
37492   }
37493
37494 }
37495
37496
37497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37498   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37499   Dali::Layer arg2 ;
37500   Dali::Layer *argp2 ;
37501
37502   arg1 = (Dali::Layer *)jarg1;
37503   argp2 = (Dali::Layer *)jarg2;
37504   if (!argp2) {
37505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37506     return ;
37507   }
37508   arg2 = *argp2;
37509   {
37510     try {
37511       (arg1)->LowerBelow(arg2);
37512     } catch (std::out_of_range& e) {
37513       {
37514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37515       };
37516     } catch (std::exception& e) {
37517       {
37518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37519       };
37520     } catch (Dali::DaliException e) {
37521       {
37522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37523       };
37524     } catch (...) {
37525       {
37526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37527       };
37528     }
37529   }
37530
37531 }
37532
37533
37534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37535   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37536
37537   arg1 = (Dali::Layer *)jarg1;
37538   {
37539     try {
37540       (arg1)->RaiseToTop();
37541     } catch (std::out_of_range& e) {
37542       {
37543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37544       };
37545     } catch (std::exception& e) {
37546       {
37547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37548       };
37549     } catch (Dali::DaliException e) {
37550       {
37551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37552       };
37553     } catch (...) {
37554       {
37555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37556       };
37557     }
37558   }
37559
37560 }
37561
37562
37563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37564   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37565
37566   arg1 = (Dali::Layer *)jarg1;
37567   {
37568     try {
37569       (arg1)->LowerToBottom();
37570     } catch (std::out_of_range& e) {
37571       {
37572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37573       };
37574     } catch (std::exception& e) {
37575       {
37576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37577       };
37578     } catch (Dali::DaliException e) {
37579       {
37580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37581       };
37582     } catch (...) {
37583       {
37584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37585       };
37586     }
37587   }
37588
37589 }
37590
37591
37592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37593   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37594   Dali::Layer arg2 ;
37595   Dali::Layer *argp2 ;
37596
37597   arg1 = (Dali::Layer *)jarg1;
37598   argp2 = (Dali::Layer *)jarg2;
37599   if (!argp2) {
37600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37601     return ;
37602   }
37603   arg2 = *argp2;
37604   {
37605     try {
37606       (arg1)->MoveAbove(arg2);
37607     } catch (std::out_of_range& e) {
37608       {
37609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37610       };
37611     } catch (std::exception& e) {
37612       {
37613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37614       };
37615     } catch (Dali::DaliException e) {
37616       {
37617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37618       };
37619     } catch (...) {
37620       {
37621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37622       };
37623     }
37624   }
37625
37626 }
37627
37628
37629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37630   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37631   Dali::Layer arg2 ;
37632   Dali::Layer *argp2 ;
37633
37634   arg1 = (Dali::Layer *)jarg1;
37635   argp2 = (Dali::Layer *)jarg2;
37636   if (!argp2) {
37637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37638     return ;
37639   }
37640   arg2 = *argp2;
37641   {
37642     try {
37643       (arg1)->MoveBelow(arg2);
37644     } catch (std::out_of_range& e) {
37645       {
37646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37647       };
37648     } catch (std::exception& e) {
37649       {
37650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37651       };
37652     } catch (Dali::DaliException e) {
37653       {
37654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37655       };
37656     } catch (...) {
37657       {
37658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37659       };
37660     }
37661   }
37662
37663 }
37664
37665
37666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37667   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37668   Dali::Layer::Behavior arg2 ;
37669
37670   arg1 = (Dali::Layer *)jarg1;
37671   arg2 = (Dali::Layer::Behavior)jarg2;
37672   {
37673     try {
37674       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
37675     } catch (std::out_of_range& e) {
37676       {
37677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37678       };
37679     } catch (std::exception& e) {
37680       {
37681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37682       };
37683     } catch (Dali::DaliException e) {
37684       {
37685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37686       };
37687     } catch (...) {
37688       {
37689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37690       };
37691     }
37692   }
37693
37694 }
37695
37696
37697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37698   int jresult ;
37699   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37700   Dali::Layer::Behavior result;
37701
37702   arg1 = (Dali::Layer *)jarg1;
37703   {
37704     try {
37705       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
37706     } catch (std::out_of_range& e) {
37707       {
37708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37709       };
37710     } catch (std::exception& e) {
37711       {
37712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37713       };
37714     } catch (Dali::DaliException e) {
37715       {
37716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37717       };
37718     } catch (...) {
37719       {
37720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37721       };
37722     }
37723   }
37724
37725   jresult = (int)result;
37726   return jresult;
37727 }
37728
37729
37730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37731   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37732   bool arg2 ;
37733
37734   arg1 = (Dali::Layer *)jarg1;
37735   arg2 = jarg2 ? true : false;
37736   {
37737     try {
37738       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
37739     } catch (std::out_of_range& e) {
37740       {
37741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37742       };
37743     } catch (std::exception& e) {
37744       {
37745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37746       };
37747     } catch (Dali::DaliException e) {
37748       {
37749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37750       };
37751     } catch (...) {
37752       {
37753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37754       };
37755     }
37756   }
37757
37758 }
37759
37760
37761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37762   unsigned int jresult ;
37763   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37764   bool result;
37765
37766   arg1 = (Dali::Layer *)jarg1;
37767   {
37768     try {
37769       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
37770     } catch (std::out_of_range& e) {
37771       {
37772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37773       };
37774     } catch (std::exception& e) {
37775       {
37776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37777       };
37778     } catch (Dali::DaliException e) {
37779       {
37780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37781       };
37782     } catch (...) {
37783       {
37784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37785       };
37786     }
37787   }
37788
37789   jresult = result;
37790   return jresult;
37791 }
37792
37793
37794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37795   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37796   int arg2 ;
37797   int arg3 ;
37798   int arg4 ;
37799   int arg5 ;
37800
37801   arg1 = (Dali::Layer *)jarg1;
37802   arg2 = (int)jarg2;
37803   arg3 = (int)jarg3;
37804   arg4 = (int)jarg4;
37805   arg5 = (int)jarg5;
37806   {
37807     try {
37808       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
37809     } catch (std::out_of_range& e) {
37810       {
37811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37812       };
37813     } catch (std::exception& e) {
37814       {
37815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37816       };
37817     } catch (Dali::DaliException e) {
37818       {
37819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37820       };
37821     } catch (...) {
37822       {
37823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37824       };
37825     }
37826   }
37827
37828 }
37829
37830
37831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37832   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37833   Dali::ClippingBox arg2 ;
37834   Dali::ClippingBox *argp2 ;
37835
37836   arg1 = (Dali::Layer *)jarg1;
37837   argp2 = (Dali::ClippingBox *)jarg2;
37838   if (!argp2) {
37839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37840     return ;
37841   }
37842   arg2 = *argp2;
37843   {
37844     try {
37845       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
37846     } catch (std::out_of_range& e) {
37847       {
37848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37849       };
37850     } catch (std::exception& e) {
37851       {
37852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37853       };
37854     } catch (Dali::DaliException e) {
37855       {
37856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37857       };
37858     } catch (...) {
37859       {
37860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37861       };
37862     }
37863   }
37864
37865 }
37866
37867
37868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37869   void * jresult ;
37870   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37871   Dali::ClippingBox result;
37872
37873   arg1 = (Dali::Layer *)jarg1;
37874   {
37875     try {
37876       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
37877     } catch (std::out_of_range& e) {
37878       {
37879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37880       };
37881     } catch (std::exception& e) {
37882       {
37883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37884       };
37885     } catch (Dali::DaliException e) {
37886       {
37887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37888       };
37889     } catch (...) {
37890       {
37891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37892       };
37893     }
37894   }
37895
37896   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37897   return jresult;
37898 }
37899
37900
37901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37902   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37903   bool arg2 ;
37904
37905   arg1 = (Dali::Layer *)jarg1;
37906   arg2 = jarg2 ? true : false;
37907   {
37908     try {
37909       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
37910     } catch (std::out_of_range& e) {
37911       {
37912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37913       };
37914     } catch (std::exception& e) {
37915       {
37916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37917       };
37918     } catch (Dali::DaliException e) {
37919       {
37920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37921       };
37922     } catch (...) {
37923       {
37924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37925       };
37926     }
37927   }
37928
37929 }
37930
37931
37932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37933   unsigned int jresult ;
37934   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37935   bool result;
37936
37937   arg1 = (Dali::Layer *)jarg1;
37938   {
37939     try {
37940       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
37941     } catch (std::out_of_range& e) {
37942       {
37943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37944       };
37945     } catch (std::exception& e) {
37946       {
37947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37948       };
37949     } catch (Dali::DaliException e) {
37950       {
37951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37952       };
37953     } catch (...) {
37954       {
37955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37956       };
37957     }
37958   }
37959
37960   jresult = result;
37961   return jresult;
37962 }
37963
37964
37965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
37966   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37967   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
37968
37969   arg1 = (Dali::Layer *)jarg1;
37970   arg2 = (Dali::Layer::SortFunctionType)jarg2;
37971   {
37972     try {
37973       (arg1)->SetSortFunction(arg2);
37974     } catch (std::out_of_range& e) {
37975       {
37976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37977       };
37978     } catch (std::exception& e) {
37979       {
37980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37981       };
37982     } catch (Dali::DaliException e) {
37983       {
37984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37985       };
37986     } catch (...) {
37987       {
37988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37989       };
37990     }
37991   }
37992
37993 }
37994
37995
37996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
37997   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37998   bool arg2 ;
37999
38000   arg1 = (Dali::Layer *)jarg1;
38001   arg2 = jarg2 ? true : false;
38002   {
38003     try {
38004       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
38005     } catch (std::out_of_range& e) {
38006       {
38007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38008       };
38009     } catch (std::exception& e) {
38010       {
38011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38012       };
38013     } catch (Dali::DaliException e) {
38014       {
38015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38016       };
38017     } catch (...) {
38018       {
38019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38020       };
38021     }
38022   }
38023
38024 }
38025
38026
38027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38028   unsigned int jresult ;
38029   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38030   bool result;
38031
38032   arg1 = (Dali::Layer *)jarg1;
38033   {
38034     try {
38035       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
38036     } catch (std::out_of_range& e) {
38037       {
38038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38039       };
38040     } catch (std::exception& e) {
38041       {
38042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38043       };
38044     } catch (Dali::DaliException e) {
38045       {
38046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38047       };
38048     } catch (...) {
38049       {
38050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38051       };
38052     }
38053   }
38054
38055   jresult = result;
38056   return jresult;
38057 }
38058
38059
38060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38061   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38062   bool arg2 ;
38063
38064   arg1 = (Dali::Layer *)jarg1;
38065   arg2 = jarg2 ? true : false;
38066   {
38067     try {
38068       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
38069     } catch (std::out_of_range& e) {
38070       {
38071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38072       };
38073     } catch (std::exception& e) {
38074       {
38075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38076       };
38077     } catch (Dali::DaliException e) {
38078       {
38079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38080       };
38081     } catch (...) {
38082       {
38083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38084       };
38085     }
38086   }
38087
38088 }
38089
38090
38091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38092   unsigned int jresult ;
38093   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38094   bool result;
38095
38096   arg1 = (Dali::Layer *)jarg1;
38097   {
38098     try {
38099       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
38100     } catch (std::out_of_range& e) {
38101       {
38102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38103       };
38104     } catch (std::exception& e) {
38105       {
38106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38107       };
38108     } catch (Dali::DaliException e) {
38109       {
38110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38111       };
38112     } catch (...) {
38113       {
38114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38115       };
38116     }
38117   }
38118
38119   jresult = result;
38120   return jresult;
38121 }
38122
38123
38124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38125   void * jresult ;
38126   Dali::Stage result;
38127
38128   {
38129     try {
38130       result = Dali::Stage::GetCurrent();
38131     } catch (std::out_of_range& e) {
38132       {
38133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38134       };
38135     } catch (std::exception& e) {
38136       {
38137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38138       };
38139     } catch (Dali::DaliException e) {
38140       {
38141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38142       };
38143     } catch (...) {
38144       {
38145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38146       };
38147     }
38148   }
38149
38150   jresult = new Dali::Stage((const Dali::Stage &)result);
38151   return jresult;
38152 }
38153
38154
38155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38156   unsigned int jresult ;
38157   bool result;
38158
38159   {
38160     try {
38161       result = (bool)Dali::Stage::IsInstalled();
38162     } catch (std::out_of_range& e) {
38163       {
38164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38165       };
38166     } catch (std::exception& e) {
38167       {
38168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38169       };
38170     } catch (Dali::DaliException e) {
38171       {
38172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38173       };
38174     } catch (...) {
38175       {
38176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38177       };
38178     }
38179   }
38180
38181   jresult = result;
38182   return jresult;
38183 }
38184
38185
38186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38187   void * jresult ;
38188   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38189   Dali::Vector2 result;
38190
38191   arg1 = (Dali::Stage *)jarg1;
38192   {
38193     try {
38194       result = ((Dali::Stage const *)arg1)->GetDpi();
38195     } catch (std::out_of_range& e) {
38196       {
38197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38198       };
38199     } catch (std::exception& e) {
38200       {
38201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38202       };
38203     } catch (Dali::DaliException e) {
38204       {
38205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38206       };
38207     } catch (...) {
38208       {
38209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38210       };
38211     }
38212   }
38213
38214   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38215   return jresult;
38216 }
38217
38218
38219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38220   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38221   float arg2 ;
38222
38223   arg1 = (Dali::Stage *)jarg1;
38224   arg2 = (float)jarg2;
38225   {
38226     try {
38227       (arg1)->KeepRendering(arg2);
38228     } catch (std::out_of_range& e) {
38229       {
38230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38231       };
38232     } catch (std::exception& e) {
38233       {
38234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38235       };
38236     } catch (Dali::DaliException e) {
38237       {
38238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38239       };
38240     } catch (...) {
38241       {
38242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38243       };
38244     }
38245   }
38246
38247 }
38248
38249
38250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38251   void * jresult ;
38252   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38253   Dali::Stage::KeyEventSignalType *result = 0 ;
38254
38255   arg1 = (Dali::Stage *)jarg1;
38256   {
38257     try {
38258       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38259     } catch (std::out_of_range& e) {
38260       {
38261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38262       };
38263     } catch (std::exception& e) {
38264       {
38265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38266       };
38267     } catch (Dali::DaliException e) {
38268       {
38269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38270       };
38271     } catch (...) {
38272       {
38273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38274       };
38275     }
38276   }
38277
38278   jresult = (void *)result;
38279   return jresult;
38280 }
38281
38282
38283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38284   void * jresult ;
38285   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38286   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38287
38288   arg1 = (Dali::Stage *)jarg1;
38289   {
38290     try {
38291       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38292     } catch (std::out_of_range& e) {
38293       {
38294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38295       };
38296     } catch (std::exception& e) {
38297       {
38298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38299       };
38300     } catch (Dali::DaliException e) {
38301       {
38302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38303       };
38304     } catch (...) {
38305       {
38306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38307       };
38308     }
38309   }
38310
38311   jresult = (void *)result;
38312   return jresult;
38313 }
38314
38315
38316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38317   void * jresult ;
38318   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38319   Dali::Stage::TouchSignalType *result = 0 ;
38320
38321   arg1 = (Dali::Stage *)jarg1;
38322   {
38323     try {
38324       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38325     } catch (std::out_of_range& e) {
38326       {
38327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38328       };
38329     } catch (std::exception& e) {
38330       {
38331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38332       };
38333     } catch (Dali::DaliException e) {
38334       {
38335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38336       };
38337     } catch (...) {
38338       {
38339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38340       };
38341     }
38342   }
38343
38344   jresult = (void *)result;
38345   return jresult;
38346 }
38347
38348
38349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38350   void * jresult ;
38351   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38352   Dali::Stage::WheelEventSignalType *result = 0 ;
38353
38354   arg1 = (Dali::Stage *)jarg1;
38355   {
38356     try {
38357       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38358     } catch (std::out_of_range& e) {
38359       {
38360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38361       };
38362     } catch (std::exception& e) {
38363       {
38364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38365       };
38366     } catch (Dali::DaliException e) {
38367       {
38368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38369       };
38370     } catch (...) {
38371       {
38372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38373       };
38374     }
38375   }
38376
38377   jresult = (void *)result;
38378   return jresult;
38379 }
38380
38381
38382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38383   void * jresult ;
38384   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38385   Dali::Stage::ContextStatusSignal *result = 0 ;
38386
38387   arg1 = (Dali::Stage *)jarg1;
38388   {
38389     try {
38390       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38391     } catch (std::out_of_range& e) {
38392       {
38393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38394       };
38395     } catch (std::exception& e) {
38396       {
38397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38398       };
38399     } catch (Dali::DaliException e) {
38400       {
38401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38402       };
38403     } catch (...) {
38404       {
38405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38406       };
38407     }
38408   }
38409
38410   jresult = (void *)result;
38411   return jresult;
38412 }
38413
38414
38415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38416   void * jresult ;
38417   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38418   Dali::Stage::ContextStatusSignal *result = 0 ;
38419
38420   arg1 = (Dali::Stage *)jarg1;
38421   {
38422     try {
38423       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38424     } catch (std::out_of_range& e) {
38425       {
38426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38427       };
38428     } catch (std::exception& e) {
38429       {
38430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38431       };
38432     } catch (Dali::DaliException e) {
38433       {
38434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38435       };
38436     } catch (...) {
38437       {
38438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38439       };
38440     }
38441   }
38442
38443   jresult = (void *)result;
38444   return jresult;
38445 }
38446
38447
38448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38449   void * jresult ;
38450   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38451   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38452
38453   arg1 = (Dali::Stage *)jarg1;
38454   {
38455     try {
38456       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
38457     } catch (std::out_of_range& e) {
38458       {
38459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38460       };
38461     } catch (std::exception& e) {
38462       {
38463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38464       };
38465     } catch (Dali::DaliException e) {
38466       {
38467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38468       };
38469     } catch (...) {
38470       {
38471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38472       };
38473     }
38474   }
38475
38476   jresult = (void *)result;
38477   return jresult;
38478 }
38479
38480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
38481   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38482   Dali::DevelStage::Rendering arg2 ;
38483
38484   arg1 = (Dali::Stage *)jarg1;
38485   arg2 = (Dali::DevelStage::Rendering)jarg2;
38486   {
38487     try {
38488       DevelStage::SetRenderingBehavior(*arg1,arg2);
38489     } catch (std::out_of_range& e) {
38490       {
38491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38492       };
38493     } catch (std::exception& e) {
38494       {
38495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38496       };
38497     } catch (Dali::DaliException e) {
38498       {
38499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38500       };
38501     } catch (...) {
38502       {
38503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38504       };
38505     }
38506   }
38507
38508 }
38509
38510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
38511
38512   int jresult ;
38513   int result ;
38514   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38515
38516   arg1 = (Dali::Stage *)jarg1;
38517   {
38518     try {
38519       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
38520     } catch (std::out_of_range& e) {
38521       {
38522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38523       };
38524     } catch (std::exception& e) {
38525       {
38526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38527       };
38528     } catch (Dali::DaliException e) {
38529       {
38530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38531       };
38532     } catch (...) {
38533       {
38534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38535       };
38536     }
38537   }
38538
38539   jresult = result;
38540   return jresult;
38541 }
38542
38543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
38544   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38545
38546   arg1 = (Dali::RelayoutContainer *)jarg1;
38547   {
38548     try {
38549       delete arg1;
38550     } catch (std::out_of_range& e) {
38551       {
38552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38553       };
38554     } catch (std::exception& e) {
38555       {
38556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38557       };
38558     } catch (Dali::DaliException e) {
38559       {
38560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38561       };
38562     } catch (...) {
38563       {
38564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38565       };
38566     }
38567   }
38568
38569 }
38570
38571
38572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
38573   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38574   Dali::Actor *arg2 = 0 ;
38575   Dali::Vector2 *arg3 = 0 ;
38576
38577   arg1 = (Dali::RelayoutContainer *)jarg1;
38578   arg2 = (Dali::Actor *)jarg2;
38579   if (!arg2) {
38580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38581     return ;
38582   }
38583   arg3 = (Dali::Vector2 *)jarg3;
38584   if (!arg3) {
38585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38586     return ;
38587   }
38588   {
38589     try {
38590       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
38591     } catch (std::out_of_range& e) {
38592       {
38593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38594       };
38595     } catch (std::exception& e) {
38596       {
38597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38598       };
38599     } catch (Dali::DaliException e) {
38600       {
38601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38602       };
38603     } catch (...) {
38604       {
38605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38606       };
38607     }
38608   }
38609
38610 }
38611
38612
38613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
38614   void * jresult ;
38615   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38616   Dali::CustomActor result;
38617
38618   arg1 = (Dali::CustomActorImpl *)jarg1;
38619   {
38620     try {
38621       result = ((Dali::CustomActorImpl const *)arg1)->Self();
38622     } catch (std::out_of_range& e) {
38623       {
38624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38625       };
38626     } catch (std::exception& e) {
38627       {
38628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38629       };
38630     } catch (Dali::DaliException e) {
38631       {
38632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38633       };
38634     } catch (...) {
38635       {
38636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38637       };
38638     }
38639   }
38640
38641   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
38642   return jresult;
38643 }
38644
38645
38646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
38647   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38648   int arg2 ;
38649
38650   arg1 = (Dali::CustomActorImpl *)jarg1;
38651   arg2 = (int)jarg2;
38652   {
38653     try {
38654       (arg1)->OnSceneConnection(arg2);
38655     } catch (std::out_of_range& e) {
38656       {
38657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38658       };
38659     } catch (std::exception& e) {
38660       {
38661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38662       };
38663     } catch (Dali::DaliException e) {
38664       {
38665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38666       };
38667     } catch (...) {
38668       {
38669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38670       };
38671     }
38672   }
38673
38674 }
38675
38676
38677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
38678   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38679
38680   arg1 = (Dali::CustomActorImpl *)jarg1;
38681   {
38682     try {
38683       (arg1)->OnSceneDisconnection();
38684     } catch (std::out_of_range& e) {
38685       {
38686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38687       };
38688     } catch (std::exception& e) {
38689       {
38690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38691       };
38692     } catch (Dali::DaliException e) {
38693       {
38694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38695       };
38696     } catch (...) {
38697       {
38698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38699       };
38700     }
38701   }
38702
38703 }
38704
38705
38706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
38707   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38708   Dali::Actor *arg2 = 0 ;
38709
38710   arg1 = (Dali::CustomActorImpl *)jarg1;
38711   arg2 = (Dali::Actor *)jarg2;
38712   if (!arg2) {
38713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38714     return ;
38715   }
38716   {
38717     try {
38718       (arg1)->OnChildAdd(*arg2);
38719     } catch (std::out_of_range& e) {
38720       {
38721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38722       };
38723     } catch (std::exception& e) {
38724       {
38725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38726       };
38727     } catch (Dali::DaliException e) {
38728       {
38729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38730       };
38731     } catch (...) {
38732       {
38733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38734       };
38735     }
38736   }
38737
38738 }
38739
38740
38741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
38742   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38743   Dali::Actor *arg2 = 0 ;
38744
38745   arg1 = (Dali::CustomActorImpl *)jarg1;
38746   arg2 = (Dali::Actor *)jarg2;
38747   if (!arg2) {
38748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38749     return ;
38750   }
38751   {
38752     try {
38753       (arg1)->OnChildRemove(*arg2);
38754     } catch (std::out_of_range& e) {
38755       {
38756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38757       };
38758     } catch (std::exception& e) {
38759       {
38760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38761       };
38762     } catch (Dali::DaliException e) {
38763       {
38764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38765       };
38766     } catch (...) {
38767       {
38768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38769       };
38770     }
38771   }
38772
38773 }
38774
38775
38776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
38777   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38778   Dali::Property::Index arg2 ;
38779   Dali::Property::Value arg3 ;
38780   Dali::Property::Value *argp3 ;
38781
38782   arg1 = (Dali::CustomActorImpl *)jarg1;
38783   arg2 = (Dali::Property::Index)jarg2;
38784   argp3 = (Dali::Property::Value *)jarg3;
38785   if (!argp3) {
38786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
38787     return ;
38788   }
38789   arg3 = *argp3;
38790   {
38791     try {
38792       (arg1)->OnPropertySet(arg2,arg3);
38793     } catch (std::out_of_range& e) {
38794       {
38795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38796       };
38797     } catch (std::exception& e) {
38798       {
38799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38800       };
38801     } catch (Dali::DaliException e) {
38802       {
38803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38804       };
38805     } catch (...) {
38806       {
38807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38808       };
38809     }
38810   }
38811
38812 }
38813
38814
38815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
38816   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38817   Dali::Vector3 *arg2 = 0 ;
38818
38819   arg1 = (Dali::CustomActorImpl *)jarg1;
38820   arg2 = (Dali::Vector3 *)jarg2;
38821   if (!arg2) {
38822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38823     return ;
38824   }
38825   {
38826     try {
38827       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
38828     } catch (std::out_of_range& e) {
38829       {
38830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38831       };
38832     } catch (std::exception& e) {
38833       {
38834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38835       };
38836     } catch (Dali::DaliException e) {
38837       {
38838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38839       };
38840     } catch (...) {
38841       {
38842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38843       };
38844     }
38845   }
38846
38847 }
38848
38849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
38850   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38851   Dali::Animation *arg2 = 0 ;
38852   Dali::Vector3 *arg3 = 0 ;
38853
38854   arg1 = (Dali::CustomActorImpl *)jarg1;
38855   arg2 = (Dali::Animation *)jarg2;
38856   if (!arg2) {
38857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
38858     return ;
38859   }
38860   arg3 = (Dali::Vector3 *)jarg3;
38861   if (!arg3) {
38862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38863     return ;
38864   }
38865   {
38866     try {
38867       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
38868     } catch (std::out_of_range& e) {
38869       {
38870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38871       };
38872     } catch (std::exception& e) {
38873       {
38874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38875       };
38876     } catch (Dali::DaliException e) {
38877       {
38878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38879       };
38880     } catch (...) {
38881       {
38882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38883       };
38884     }
38885   }
38886 }
38887
38888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
38889   unsigned int jresult ;
38890   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38891   Dali::HoverEvent *arg2 = 0 ;
38892   bool result;
38893
38894   arg1 = (Dali::CustomActorImpl *)jarg1;
38895   arg2 = (Dali::HoverEvent *)jarg2;
38896   if (!arg2) {
38897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
38898     return 0;
38899   }
38900   {
38901     try {
38902       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
38903     } catch (std::out_of_range& e) {
38904       {
38905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38906       };
38907     } catch (std::exception& e) {
38908       {
38909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38910       };
38911     } catch (Dali::DaliException e) {
38912       {
38913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38914       };
38915     } catch (...) {
38916       {
38917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38918       };
38919     }
38920   }
38921
38922   jresult = result;
38923   return jresult;
38924 }
38925
38926
38927 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
38928   unsigned int jresult ;
38929   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38930   Dali::KeyEvent *arg2 = 0 ;
38931   bool result;
38932
38933   arg1 = (Dali::CustomActorImpl *)jarg1;
38934   arg2 = (Dali::KeyEvent *)jarg2;
38935   if (!arg2) {
38936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
38937     return 0;
38938   }
38939   {
38940     try {
38941       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
38942     } catch (std::out_of_range& e) {
38943       {
38944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38945       };
38946     } catch (std::exception& e) {
38947       {
38948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38949       };
38950     } catch (Dali::DaliException e) {
38951       {
38952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38953       };
38954     } catch (...) {
38955       {
38956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38957       };
38958     }
38959   }
38960
38961   jresult = result;
38962   return jresult;
38963 }
38964
38965
38966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
38967   unsigned int jresult ;
38968   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38969   Dali::WheelEvent *arg2 = 0 ;
38970   bool result;
38971
38972   arg1 = (Dali::CustomActorImpl *)jarg1;
38973   arg2 = (Dali::WheelEvent *)jarg2;
38974   if (!arg2) {
38975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
38976     return 0;
38977   }
38978   {
38979     try {
38980       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
38981     } catch (std::out_of_range& e) {
38982       {
38983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38984       };
38985     } catch (std::exception& e) {
38986       {
38987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38988       };
38989     } catch (Dali::DaliException e) {
38990       {
38991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38992       };
38993     } catch (...) {
38994       {
38995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38996       };
38997     }
38998   }
38999
39000   jresult = result;
39001   return jresult;
39002 }
39003
39004
39005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39006   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39007   Dali::Vector2 *arg2 = 0 ;
39008   Dali::RelayoutContainer *arg3 = 0 ;
39009
39010   arg1 = (Dali::CustomActorImpl *)jarg1;
39011   arg2 = (Dali::Vector2 *)jarg2;
39012   if (!arg2) {
39013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39014     return ;
39015   }
39016   arg3 = (Dali::RelayoutContainer *)jarg3;
39017   if (!arg3) {
39018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39019     return ;
39020   }
39021   {
39022     try {
39023       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39024     } catch (std::out_of_range& e) {
39025       {
39026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39027       };
39028     } catch (std::exception& e) {
39029       {
39030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39031       };
39032     } catch (Dali::DaliException e) {
39033       {
39034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39035       };
39036     } catch (...) {
39037       {
39038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39039       };
39040     }
39041   }
39042
39043 }
39044
39045
39046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39047   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39048   Dali::ResizePolicy::Type arg2 ;
39049   Dali::Dimension::Type arg3 ;
39050
39051   arg1 = (Dali::CustomActorImpl *)jarg1;
39052   arg2 = (Dali::ResizePolicy::Type)jarg2;
39053   arg3 = (Dali::Dimension::Type)jarg3;
39054   {
39055     try {
39056       (arg1)->OnSetResizePolicy(arg2,arg3);
39057     } catch (std::out_of_range& e) {
39058       {
39059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39060       };
39061     } catch (std::exception& e) {
39062       {
39063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39064       };
39065     } catch (Dali::DaliException e) {
39066       {
39067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39068       };
39069     } catch (...) {
39070       {
39071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39072       };
39073     }
39074   }
39075
39076 }
39077
39078
39079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39080   void * jresult ;
39081   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39082   Dali::Vector3 result;
39083
39084   arg1 = (Dali::CustomActorImpl *)jarg1;
39085   {
39086     try {
39087       result = (arg1)->GetNaturalSize();
39088     } catch (std::out_of_range& e) {
39089       {
39090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39091       };
39092     } catch (std::exception& e) {
39093       {
39094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39095       };
39096     } catch (Dali::DaliException e) {
39097       {
39098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39099       };
39100     } catch (...) {
39101       {
39102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39103       };
39104     }
39105   }
39106
39107   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39108   return jresult;
39109 }
39110
39111
39112 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39113   float jresult ;
39114   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39115   Dali::Actor *arg2 = 0 ;
39116   Dali::Dimension::Type arg3 ;
39117   float result;
39118
39119   arg1 = (Dali::CustomActorImpl *)jarg1;
39120   arg2 = (Dali::Actor *)jarg2;
39121   if (!arg2) {
39122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39123     return 0;
39124   }
39125   arg3 = (Dali::Dimension::Type)jarg3;
39126   {
39127     try {
39128       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39129     } catch (std::out_of_range& e) {
39130       {
39131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39132       };
39133     } catch (std::exception& e) {
39134       {
39135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39136       };
39137     } catch (Dali::DaliException e) {
39138       {
39139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39140       };
39141     } catch (...) {
39142       {
39143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39144       };
39145     }
39146   }
39147
39148   jresult = result;
39149   return jresult;
39150 }
39151
39152
39153 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39154   float jresult ;
39155   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39156   float arg2 ;
39157   float result;
39158
39159   arg1 = (Dali::CustomActorImpl *)jarg1;
39160   arg2 = (float)jarg2;
39161   {
39162     try {
39163       result = (float)(arg1)->GetHeightForWidth(arg2);
39164     } catch (std::out_of_range& e) {
39165       {
39166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39167       };
39168     } catch (std::exception& e) {
39169       {
39170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39171       };
39172     } catch (Dali::DaliException e) {
39173       {
39174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39175       };
39176     } catch (...) {
39177       {
39178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39179       };
39180     }
39181   }
39182
39183   jresult = result;
39184   return jresult;
39185 }
39186
39187
39188 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39189   float jresult ;
39190   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39191   float arg2 ;
39192   float result;
39193
39194   arg1 = (Dali::CustomActorImpl *)jarg1;
39195   arg2 = (float)jarg2;
39196   {
39197     try {
39198       result = (float)(arg1)->GetWidthForHeight(arg2);
39199     } catch (std::out_of_range& e) {
39200       {
39201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39202       };
39203     } catch (std::exception& e) {
39204       {
39205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39206       };
39207     } catch (Dali::DaliException e) {
39208       {
39209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39210       };
39211     } catch (...) {
39212       {
39213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39214       };
39215     }
39216   }
39217
39218   jresult = result;
39219   return jresult;
39220 }
39221
39222
39223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39224   unsigned int jresult ;
39225   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39226   Dali::Dimension::Type arg2 ;
39227   bool result;
39228
39229   arg1 = (Dali::CustomActorImpl *)jarg1;
39230   arg2 = (Dali::Dimension::Type)jarg2;
39231   {
39232     try {
39233       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39234     } catch (std::out_of_range& e) {
39235       {
39236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39237       };
39238     } catch (std::exception& e) {
39239       {
39240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39241       };
39242     } catch (Dali::DaliException e) {
39243       {
39244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39245       };
39246     } catch (...) {
39247       {
39248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39249       };
39250     }
39251   }
39252
39253   jresult = result;
39254   return jresult;
39255 }
39256
39257
39258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39259   unsigned int jresult ;
39260   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39261   bool result;
39262
39263   arg1 = (Dali::CustomActorImpl *)jarg1;
39264   {
39265     try {
39266       result = (bool)(arg1)->RelayoutDependentOnChildren();
39267     } catch (std::out_of_range& e) {
39268       {
39269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39270       };
39271     } catch (std::exception& e) {
39272       {
39273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39274       };
39275     } catch (Dali::DaliException e) {
39276       {
39277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39278       };
39279     } catch (...) {
39280       {
39281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39282       };
39283     }
39284   }
39285
39286   jresult = result;
39287   return jresult;
39288 }
39289
39290
39291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39292   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39293   Dali::Dimension::Type arg2 ;
39294
39295   arg1 = (Dali::CustomActorImpl *)jarg1;
39296   arg2 = (Dali::Dimension::Type)jarg2;
39297   {
39298     try {
39299       (arg1)->OnCalculateRelayoutSize(arg2);
39300     } catch (std::out_of_range& e) {
39301       {
39302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39303       };
39304     } catch (std::exception& e) {
39305       {
39306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39307       };
39308     } catch (Dali::DaliException e) {
39309       {
39310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39311       };
39312     } catch (...) {
39313       {
39314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39315       };
39316     }
39317   }
39318
39319 }
39320
39321
39322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39323   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39324   float arg2 ;
39325   Dali::Dimension::Type arg3 ;
39326
39327   arg1 = (Dali::CustomActorImpl *)jarg1;
39328   arg2 = (float)jarg2;
39329   arg3 = (Dali::Dimension::Type)jarg3;
39330   {
39331     try {
39332       (arg1)->OnLayoutNegotiated(arg2,arg3);
39333     } catch (std::out_of_range& e) {
39334       {
39335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39336       };
39337     } catch (std::exception& e) {
39338       {
39339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39340       };
39341     } catch (Dali::DaliException e) {
39342       {
39343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39344       };
39345     } catch (...) {
39346       {
39347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39348       };
39349     }
39350   }
39351
39352 }
39353
39354
39355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39356   unsigned int jresult ;
39357   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39358   bool result;
39359
39360   arg1 = (Dali::CustomActorImpl *)jarg1;
39361   {
39362     try {
39363       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39364     } catch (std::out_of_range& e) {
39365       {
39366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39367       };
39368     } catch (std::exception& e) {
39369       {
39370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39371       };
39372     } catch (Dali::DaliException e) {
39373       {
39374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39375       };
39376     } catch (...) {
39377       {
39378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39379       };
39380     }
39381   }
39382
39383   jresult = result;
39384   return jresult;
39385 }
39386
39387
39388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39389   unsigned int jresult ;
39390   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39391   bool result;
39392
39393   arg1 = (Dali::CustomActorImpl *)jarg1;
39394   {
39395     try {
39396       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39397     } catch (std::out_of_range& e) {
39398       {
39399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39400       };
39401     } catch (std::exception& e) {
39402       {
39403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39404       };
39405     } catch (Dali::DaliException e) {
39406       {
39407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39408       };
39409     } catch (...) {
39410       {
39411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39412       };
39413     }
39414   }
39415
39416   jresult = result;
39417   return jresult;
39418 }
39419
39420
39421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39422   unsigned int jresult ;
39423   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39424   bool result;
39425
39426   arg1 = (Dali::CustomActorImpl *)jarg1;
39427   {
39428     try {
39429       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39430     } catch (std::out_of_range& e) {
39431       {
39432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39433       };
39434     } catch (std::exception& e) {
39435       {
39436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39437       };
39438     } catch (Dali::DaliException e) {
39439       {
39440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39441       };
39442     } catch (...) {
39443       {
39444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39445       };
39446     }
39447   }
39448
39449   jresult = result;
39450   return jresult;
39451 }
39452
39453
39454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
39455   unsigned int jresult ;
39456   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39457   bool result;
39458
39459   arg1 = (Dali::CustomActorImpl *)jarg1;
39460   {
39461     try {
39462       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
39463     } catch (std::out_of_range& e) {
39464       {
39465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39466       };
39467     } catch (std::exception& e) {
39468       {
39469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39470       };
39471     } catch (Dali::DaliException e) {
39472       {
39473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39474       };
39475     } catch (...) {
39476       {
39477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39478       };
39479     }
39480   }
39481
39482   jresult = result;
39483   return jresult;
39484 }
39485
39486
39487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
39488   void * jresult ;
39489   Dali::CustomActor *result = 0 ;
39490
39491   {
39492     try {
39493       result = (Dali::CustomActor *)new Dali::CustomActor();
39494     } catch (std::out_of_range& e) {
39495       {
39496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39497       };
39498     } catch (std::exception& e) {
39499       {
39500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39501       };
39502     } catch (Dali::DaliException e) {
39503       {
39504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39505       };
39506     } catch (...) {
39507       {
39508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39509       };
39510     }
39511   }
39512
39513   jresult = (void *)result;
39514   return jresult;
39515 }
39516
39517
39518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
39519   void * jresult ;
39520   Dali::BaseHandle arg1 ;
39521   Dali::BaseHandle *argp1 ;
39522   Dali::CustomActor result;
39523
39524   argp1 = (Dali::BaseHandle *)jarg1;
39525   if (!argp1) {
39526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39527     return 0;
39528   }
39529   arg1 = *argp1;
39530   {
39531     try {
39532       result = Dali::CustomActor::DownCast(arg1);
39533     } catch (std::out_of_range& e) {
39534       {
39535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39536       };
39537     } catch (std::exception& e) {
39538       {
39539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39540       };
39541     } catch (Dali::DaliException e) {
39542       {
39543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39544       };
39545     } catch (...) {
39546       {
39547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39548       };
39549     }
39550   }
39551
39552   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39553   return jresult;
39554 }
39555
39556
39557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
39558   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39559
39560   arg1 = (Dali::CustomActor *)jarg1;
39561   {
39562     try {
39563       delete arg1;
39564     } catch (std::out_of_range& e) {
39565       {
39566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39567       };
39568     } catch (std::exception& e) {
39569       {
39570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39571       };
39572     } catch (Dali::DaliException e) {
39573       {
39574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39575       };
39576     } catch (...) {
39577       {
39578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39579       };
39580     }
39581   }
39582
39583 }
39584
39585
39586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
39587   void * jresult ;
39588   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39589   Dali::CustomActorImpl *result = 0 ;
39590
39591   arg1 = (Dali::CustomActor *)jarg1;
39592   {
39593     try {
39594       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
39595     } catch (std::out_of_range& e) {
39596       {
39597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39598       };
39599     } catch (std::exception& e) {
39600       {
39601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39602       };
39603     } catch (Dali::DaliException e) {
39604       {
39605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39606       };
39607     } catch (...) {
39608       {
39609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39610       };
39611     }
39612   }
39613
39614   jresult = (void *)result;
39615   return jresult;
39616 }
39617
39618
39619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
39620   void * jresult ;
39621   Dali::CustomActorImpl *arg1 = 0 ;
39622   Dali::CustomActor *result = 0 ;
39623
39624   arg1 = (Dali::CustomActorImpl *)jarg1;
39625   if (!arg1) {
39626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
39627     return 0;
39628   }
39629   {
39630     try {
39631       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
39632     } catch (std::out_of_range& e) {
39633       {
39634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39635       };
39636     } catch (std::exception& e) {
39637       {
39638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39639       };
39640     } catch (Dali::DaliException e) {
39641       {
39642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39643       };
39644     } catch (...) {
39645       {
39646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39647       };
39648     }
39649   }
39650
39651   jresult = (void *)result;
39652   return jresult;
39653 }
39654
39655
39656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
39657   void * jresult ;
39658   Dali::CustomActor *arg1 = 0 ;
39659   Dali::CustomActor *result = 0 ;
39660
39661   arg1 = (Dali::CustomActor *)jarg1;
39662   if (!arg1) {
39663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39664     return 0;
39665   }
39666   {
39667     try {
39668       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
39669     } catch (std::out_of_range& e) {
39670       {
39671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39672       };
39673     } catch (std::exception& e) {
39674       {
39675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39676       };
39677     } catch (Dali::DaliException e) {
39678       {
39679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39680       };
39681     } catch (...) {
39682       {
39683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39684       };
39685     }
39686   }
39687
39688   jresult = (void *)result;
39689   return jresult;
39690 }
39691
39692
39693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
39694   void * jresult ;
39695   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39696   Dali::CustomActor *arg2 = 0 ;
39697   Dali::CustomActor *result = 0 ;
39698
39699   arg1 = (Dali::CustomActor *)jarg1;
39700   arg2 = (Dali::CustomActor *)jarg2;
39701   if (!arg2) {
39702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39703     return 0;
39704   }
39705   {
39706     try {
39707       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
39708     } catch (std::out_of_range& e) {
39709       {
39710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39711       };
39712     } catch (std::exception& e) {
39713       {
39714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39715       };
39716     } catch (Dali::DaliException e) {
39717       {
39718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39719       };
39720     } catch (...) {
39721       {
39722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39723       };
39724     }
39725   }
39726
39727   jresult = (void *)result;
39728   return jresult;
39729 }
39730
39731
39732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
39733   int jresult ;
39734   int result;
39735
39736   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
39737   jresult = (int)result;
39738   return jresult;
39739 }
39740
39741
39742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
39743   int jresult ;
39744   int result;
39745
39746   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
39747   jresult = (int)result;
39748   return jresult;
39749 }
39750
39751
39752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
39753   int jresult ;
39754   int result;
39755
39756   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
39757   jresult = (int)result;
39758   return jresult;
39759 }
39760
39761
39762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
39763   int jresult ;
39764   int result;
39765
39766   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
39767   jresult = (int)result;
39768   return jresult;
39769 }
39770
39771
39772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
39773   int jresult ;
39774   int result;
39775
39776   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
39777   jresult = (int)result;
39778   return jresult;
39779 }
39780
39781
39782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
39783   int jresult ;
39784   int result;
39785
39786   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
39787   jresult = (int)result;
39788   return jresult;
39789 }
39790
39791
39792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
39793   int jresult ;
39794   int result;
39795
39796   result = (int)Dali::PanGestureDetector::Property::PANNING;
39797   jresult = (int)result;
39798   return jresult;
39799 }
39800
39801
39802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
39803   void * jresult ;
39804   Dali::PanGestureDetector::Property *result = 0 ;
39805
39806   {
39807     try {
39808       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
39809     } catch (std::out_of_range& e) {
39810       {
39811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39812       };
39813     } catch (std::exception& e) {
39814       {
39815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39816       };
39817     } catch (Dali::DaliException e) {
39818       {
39819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39820       };
39821     } catch (...) {
39822       {
39823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39824       };
39825     }
39826   }
39827
39828   jresult = (void *)result;
39829   return jresult;
39830 }
39831
39832
39833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
39834   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
39835
39836   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
39837   {
39838     try {
39839       delete arg1;
39840     } catch (std::out_of_range& e) {
39841       {
39842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39843       };
39844     } catch (std::exception& e) {
39845       {
39846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39847       };
39848     } catch (Dali::DaliException e) {
39849       {
39850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39851       };
39852     } catch (...) {
39853       {
39854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39855       };
39856     }
39857   }
39858
39859 }
39860
39861
39862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
39863   void * jresult ;
39864   Dali::Radian *result = 0 ;
39865
39866   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
39867   jresult = (void *)result;
39868   return jresult;
39869 }
39870
39871
39872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
39873   void * jresult ;
39874   Dali::Radian *result = 0 ;
39875
39876   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
39877   jresult = (void *)result;
39878   return jresult;
39879 }
39880
39881
39882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
39883   void * jresult ;
39884   Dali::Radian *result = 0 ;
39885
39886   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
39887   jresult = (void *)result;
39888   return jresult;
39889 }
39890
39891
39892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
39893   void * jresult ;
39894   Dali::Radian *result = 0 ;
39895
39896   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
39897   jresult = (void *)result;
39898   return jresult;
39899 }
39900
39901
39902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
39903   void * jresult ;
39904   Dali::Radian *result = 0 ;
39905
39906   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
39907   jresult = (void *)result;
39908   return jresult;
39909 }
39910
39911
39912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
39913   void * jresult ;
39914   Dali::Radian *result = 0 ;
39915
39916   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
39917   jresult = (void *)result;
39918   return jresult;
39919 }
39920
39921
39922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
39923   void * jresult ;
39924   Dali::Radian *result = 0 ;
39925
39926   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
39927   jresult = (void *)result;
39928   return jresult;
39929 }
39930
39931
39932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
39933   void * jresult ;
39934   Dali::PanGestureDetector *result = 0 ;
39935
39936   {
39937     try {
39938       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
39939     } catch (std::out_of_range& e) {
39940       {
39941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39942       };
39943     } catch (std::exception& e) {
39944       {
39945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39946       };
39947     } catch (Dali::DaliException e) {
39948       {
39949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39950       };
39951     } catch (...) {
39952       {
39953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39954       };
39955     }
39956   }
39957
39958   jresult = (void *)result;
39959   return jresult;
39960 }
39961
39962
39963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
39964   void * jresult ;
39965   Dali::PanGestureDetector result;
39966
39967   {
39968     try {
39969       result = Dali::PanGestureDetector::New();
39970     } catch (std::out_of_range& e) {
39971       {
39972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39973       };
39974     } catch (std::exception& e) {
39975       {
39976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39977       };
39978     } catch (Dali::DaliException e) {
39979       {
39980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39981       };
39982     } catch (...) {
39983       {
39984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39985       };
39986     }
39987   }
39988
39989   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
39990   return jresult;
39991 }
39992
39993
39994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
39995   void * jresult ;
39996   Dali::BaseHandle arg1 ;
39997   Dali::BaseHandle *argp1 ;
39998   Dali::PanGestureDetector result;
39999
40000   argp1 = (Dali::BaseHandle *)jarg1;
40001   if (!argp1) {
40002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40003     return 0;
40004   }
40005   arg1 = *argp1;
40006   {
40007     try {
40008       result = Dali::PanGestureDetector::DownCast(arg1);
40009     } catch (std::out_of_range& e) {
40010       {
40011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40012       };
40013     } catch (std::exception& e) {
40014       {
40015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40016       };
40017     } catch (Dali::DaliException e) {
40018       {
40019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40020       };
40021     } catch (...) {
40022       {
40023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40024       };
40025     }
40026   }
40027
40028   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40029   return jresult;
40030 }
40031
40032
40033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40034   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40035
40036   arg1 = (Dali::PanGestureDetector *)jarg1;
40037   {
40038     try {
40039       delete arg1;
40040     } catch (std::out_of_range& e) {
40041       {
40042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40043       };
40044     } catch (std::exception& e) {
40045       {
40046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40047       };
40048     } catch (Dali::DaliException e) {
40049       {
40050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40051       };
40052     } catch (...) {
40053       {
40054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40055       };
40056     }
40057   }
40058
40059 }
40060
40061
40062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40063   void * jresult ;
40064   Dali::PanGestureDetector *arg1 = 0 ;
40065   Dali::PanGestureDetector *result = 0 ;
40066
40067   arg1 = (Dali::PanGestureDetector *)jarg1;
40068   if (!arg1) {
40069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40070     return 0;
40071   }
40072   {
40073     try {
40074       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40075     } catch (std::out_of_range& e) {
40076       {
40077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40078       };
40079     } catch (std::exception& e) {
40080       {
40081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40082       };
40083     } catch (Dali::DaliException e) {
40084       {
40085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40086       };
40087     } catch (...) {
40088       {
40089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40090       };
40091     }
40092   }
40093
40094   jresult = (void *)result;
40095   return jresult;
40096 }
40097
40098
40099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40100   void * jresult ;
40101   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40102   Dali::PanGestureDetector *arg2 = 0 ;
40103   Dali::PanGestureDetector *result = 0 ;
40104
40105   arg1 = (Dali::PanGestureDetector *)jarg1;
40106   arg2 = (Dali::PanGestureDetector *)jarg2;
40107   if (!arg2) {
40108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40109     return 0;
40110   }
40111   {
40112     try {
40113       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40114     } catch (std::out_of_range& e) {
40115       {
40116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40117       };
40118     } catch (std::exception& e) {
40119       {
40120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40121       };
40122     } catch (Dali::DaliException e) {
40123       {
40124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40125       };
40126     } catch (...) {
40127       {
40128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40129       };
40130     }
40131   }
40132
40133   jresult = (void *)result;
40134   return jresult;
40135 }
40136
40137
40138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40139   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40140   unsigned int arg2 ;
40141
40142   arg1 = (Dali::PanGestureDetector *)jarg1;
40143   arg2 = (unsigned int)jarg2;
40144   {
40145     try {
40146       (arg1)->SetMinimumTouchesRequired(arg2);
40147     } catch (std::out_of_range& e) {
40148       {
40149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40150       };
40151     } catch (std::exception& e) {
40152       {
40153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40154       };
40155     } catch (Dali::DaliException e) {
40156       {
40157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40158       };
40159     } catch (...) {
40160       {
40161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40162       };
40163     }
40164   }
40165
40166 }
40167
40168
40169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40170   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40171   unsigned int arg2 ;
40172
40173   arg1 = (Dali::PanGestureDetector *)jarg1;
40174   arg2 = (unsigned int)jarg2;
40175   {
40176     try {
40177       (arg1)->SetMaximumTouchesRequired(arg2);
40178     } catch (std::out_of_range& e) {
40179       {
40180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40181       };
40182     } catch (std::exception& e) {
40183       {
40184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40185       };
40186     } catch (Dali::DaliException e) {
40187       {
40188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40189       };
40190     } catch (...) {
40191       {
40192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40193       };
40194     }
40195   }
40196
40197 }
40198
40199
40200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40201   unsigned int jresult ;
40202   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40203   unsigned int result;
40204
40205   arg1 = (Dali::PanGestureDetector *)jarg1;
40206   {
40207     try {
40208       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40209     } catch (std::out_of_range& e) {
40210       {
40211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40212       };
40213     } catch (std::exception& e) {
40214       {
40215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40216       };
40217     } catch (Dali::DaliException e) {
40218       {
40219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40220       };
40221     } catch (...) {
40222       {
40223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40224       };
40225     }
40226   }
40227
40228   jresult = result;
40229   return jresult;
40230 }
40231
40232
40233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40234   unsigned int jresult ;
40235   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40236   unsigned int result;
40237
40238   arg1 = (Dali::PanGestureDetector *)jarg1;
40239   {
40240     try {
40241       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40242     } catch (std::out_of_range& e) {
40243       {
40244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40245       };
40246     } catch (std::exception& e) {
40247       {
40248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40249       };
40250     } catch (Dali::DaliException e) {
40251       {
40252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40253       };
40254     } catch (...) {
40255       {
40256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40257       };
40258     }
40259   }
40260
40261   jresult = result;
40262   return jresult;
40263 }
40264
40265
40266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40267   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40268   Dali::Radian arg2 ;
40269   Dali::Radian arg3 ;
40270   Dali::Radian *argp2 ;
40271   Dali::Radian *argp3 ;
40272
40273   arg1 = (Dali::PanGestureDetector *)jarg1;
40274   argp2 = (Dali::Radian *)jarg2;
40275   if (!argp2) {
40276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40277     return ;
40278   }
40279   arg2 = *argp2;
40280   argp3 = (Dali::Radian *)jarg3;
40281   if (!argp3) {
40282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40283     return ;
40284   }
40285   arg3 = *argp3;
40286   {
40287     try {
40288       (arg1)->AddAngle(arg2,arg3);
40289     } catch (std::out_of_range& e) {
40290       {
40291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40292       };
40293     } catch (std::exception& e) {
40294       {
40295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40296       };
40297     } catch (Dali::DaliException e) {
40298       {
40299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40300       };
40301     } catch (...) {
40302       {
40303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40304       };
40305     }
40306   }
40307
40308 }
40309
40310
40311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40312   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40313   Dali::Radian arg2 ;
40314   Dali::Radian *argp2 ;
40315
40316   arg1 = (Dali::PanGestureDetector *)jarg1;
40317   argp2 = (Dali::Radian *)jarg2;
40318   if (!argp2) {
40319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40320     return ;
40321   }
40322   arg2 = *argp2;
40323   {
40324     try {
40325       (arg1)->AddAngle(arg2);
40326     } catch (std::out_of_range& e) {
40327       {
40328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40329       };
40330     } catch (std::exception& e) {
40331       {
40332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40333       };
40334     } catch (Dali::DaliException e) {
40335       {
40336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40337       };
40338     } catch (...) {
40339       {
40340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40341       };
40342     }
40343   }
40344
40345 }
40346
40347
40348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40349   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40350   Dali::Radian arg2 ;
40351   Dali::Radian arg3 ;
40352   Dali::Radian *argp2 ;
40353   Dali::Radian *argp3 ;
40354
40355   arg1 = (Dali::PanGestureDetector *)jarg1;
40356   argp2 = (Dali::Radian *)jarg2;
40357   if (!argp2) {
40358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40359     return ;
40360   }
40361   arg2 = *argp2;
40362   argp3 = (Dali::Radian *)jarg3;
40363   if (!argp3) {
40364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40365     return ;
40366   }
40367   arg3 = *argp3;
40368   {
40369     try {
40370       (arg1)->AddDirection(arg2,arg3);
40371     } catch (std::out_of_range& e) {
40372       {
40373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40374       };
40375     } catch (std::exception& e) {
40376       {
40377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40378       };
40379     } catch (Dali::DaliException e) {
40380       {
40381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40382       };
40383     } catch (...) {
40384       {
40385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40386       };
40387     }
40388   }
40389
40390 }
40391
40392
40393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40394   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40395   Dali::Radian arg2 ;
40396   Dali::Radian *argp2 ;
40397
40398   arg1 = (Dali::PanGestureDetector *)jarg1;
40399   argp2 = (Dali::Radian *)jarg2;
40400   if (!argp2) {
40401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40402     return ;
40403   }
40404   arg2 = *argp2;
40405   {
40406     try {
40407       (arg1)->AddDirection(arg2);
40408     } catch (std::out_of_range& e) {
40409       {
40410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40411       };
40412     } catch (std::exception& e) {
40413       {
40414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40415       };
40416     } catch (Dali::DaliException e) {
40417       {
40418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40419       };
40420     } catch (...) {
40421       {
40422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40423       };
40424     }
40425   }
40426
40427 }
40428
40429
40430 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40431   unsigned long jresult ;
40432   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40433   size_t result;
40434
40435   arg1 = (Dali::PanGestureDetector *)jarg1;
40436   {
40437     try {
40438       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
40439     } catch (std::out_of_range& e) {
40440       {
40441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40442       };
40443     } catch (std::exception& e) {
40444       {
40445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40446       };
40447     } catch (Dali::DaliException e) {
40448       {
40449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40450       };
40451     } catch (...) {
40452       {
40453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40454       };
40455     }
40456   }
40457
40458   jresult = (unsigned long)result;
40459   return jresult;
40460 }
40461
40462
40463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
40464   void * jresult ;
40465   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40466   size_t arg2 ;
40467   Dali::PanGestureDetector::AngleThresholdPair result;
40468
40469   arg1 = (Dali::PanGestureDetector *)jarg1;
40470   arg2 = (size_t)jarg2;
40471   {
40472     try {
40473       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
40474     } catch (std::out_of_range& e) {
40475       {
40476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40477       };
40478     } catch (std::exception& e) {
40479       {
40480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40481       };
40482     } catch (Dali::DaliException e) {
40483       {
40484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40485       };
40486     } catch (...) {
40487       {
40488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40489       };
40490     }
40491   }
40492
40493   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
40494   return jresult;
40495 }
40496
40497
40498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
40499   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40500
40501   arg1 = (Dali::PanGestureDetector *)jarg1;
40502   {
40503     try {
40504       (arg1)->ClearAngles();
40505     } catch (std::out_of_range& e) {
40506       {
40507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40508       };
40509     } catch (std::exception& e) {
40510       {
40511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40512       };
40513     } catch (Dali::DaliException e) {
40514       {
40515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40516       };
40517     } catch (...) {
40518       {
40519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40520       };
40521     }
40522   }
40523
40524 }
40525
40526
40527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
40528   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40529   Dali::Radian arg2 ;
40530   Dali::Radian *argp2 ;
40531
40532   arg1 = (Dali::PanGestureDetector *)jarg1;
40533   argp2 = (Dali::Radian *)jarg2;
40534   if (!argp2) {
40535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40536     return ;
40537   }
40538   arg2 = *argp2;
40539   {
40540     try {
40541       (arg1)->RemoveAngle(arg2);
40542     } catch (std::out_of_range& e) {
40543       {
40544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40545       };
40546     } catch (std::exception& e) {
40547       {
40548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40549       };
40550     } catch (Dali::DaliException e) {
40551       {
40552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40553       };
40554     } catch (...) {
40555       {
40556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40557       };
40558     }
40559   }
40560
40561 }
40562
40563
40564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
40565   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40566   Dali::Radian arg2 ;
40567   Dali::Radian *argp2 ;
40568
40569   arg1 = (Dali::PanGestureDetector *)jarg1;
40570   argp2 = (Dali::Radian *)jarg2;
40571   if (!argp2) {
40572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40573     return ;
40574   }
40575   arg2 = *argp2;
40576   {
40577     try {
40578       (arg1)->RemoveDirection(arg2);
40579     } catch (std::out_of_range& e) {
40580       {
40581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40582       };
40583     } catch (std::exception& e) {
40584       {
40585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40586       };
40587     } catch (Dali::DaliException e) {
40588       {
40589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40590       };
40591     } catch (...) {
40592       {
40593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40594       };
40595     }
40596   }
40597
40598 }
40599
40600
40601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
40602   void * jresult ;
40603   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40604   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
40605
40606   arg1 = (Dali::PanGestureDetector *)jarg1;
40607   {
40608     try {
40609       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
40610     } catch (std::out_of_range& e) {
40611       {
40612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40613       };
40614     } catch (std::exception& e) {
40615       {
40616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40617       };
40618     } catch (Dali::DaliException e) {
40619       {
40620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40621       };
40622     } catch (...) {
40623       {
40624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40625       };
40626     }
40627   }
40628
40629   jresult = (void *)result;
40630   return jresult;
40631 }
40632
40633
40634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
40635   Dali::PanGesture *arg1 = 0 ;
40636
40637   arg1 = (Dali::PanGesture *)jarg1;
40638   if (!arg1) {
40639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40640     return ;
40641   }
40642   {
40643     try {
40644       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
40645     } catch (std::out_of_range& e) {
40646       {
40647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40648       };
40649     } catch (std::exception& e) {
40650       {
40651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40652       };
40653     } catch (Dali::DaliException e) {
40654       {
40655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40656       };
40657     } catch (...) {
40658       {
40659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40660       };
40661     }
40662   }
40663
40664 }
40665
40666
40667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
40668   void * jresult ;
40669   Dali::PanGesture *result = 0 ;
40670
40671   {
40672     try {
40673       result = (Dali::PanGesture *)new Dali::PanGesture();
40674     } catch (std::out_of_range& e) {
40675       {
40676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40677       };
40678     } catch (std::exception& e) {
40679       {
40680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40681       };
40682     } catch (Dali::DaliException e) {
40683       {
40684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40685       };
40686     } catch (...) {
40687       {
40688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40689       };
40690     }
40691   }
40692
40693   jresult = (void *)result;
40694   return jresult;
40695 }
40696
40697
40698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
40699   void * jresult ;
40700   Dali::Gesture::State arg1 ;
40701   Dali::PanGesture *result = 0 ;
40702
40703   arg1 = (Dali::Gesture::State)jarg1;
40704   {
40705     try {
40706       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
40707     } catch (std::out_of_range& e) {
40708       {
40709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40710       };
40711     } catch (std::exception& e) {
40712       {
40713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40714       };
40715     } catch (Dali::DaliException e) {
40716       {
40717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40718       };
40719     } catch (...) {
40720       {
40721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40722       };
40723     }
40724   }
40725
40726   jresult = (void *)result;
40727   return jresult;
40728 }
40729
40730
40731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
40732   void * jresult ;
40733   Dali::PanGesture *arg1 = 0 ;
40734   Dali::PanGesture *result = 0 ;
40735
40736   arg1 = (Dali::PanGesture *)jarg1;
40737   if (!arg1) {
40738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40739     return 0;
40740   }
40741   {
40742     try {
40743       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
40744     } catch (std::out_of_range& e) {
40745       {
40746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40747       };
40748     } catch (std::exception& e) {
40749       {
40750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40751       };
40752     } catch (Dali::DaliException e) {
40753       {
40754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40755       };
40756     } catch (...) {
40757       {
40758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40759       };
40760     }
40761   }
40762
40763   jresult = (void *)result;
40764   return jresult;
40765 }
40766
40767
40768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
40769   void * jresult ;
40770   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40771   Dali::PanGesture *arg2 = 0 ;
40772   Dali::PanGesture *result = 0 ;
40773
40774   arg1 = (Dali::PanGesture *)jarg1;
40775   arg2 = (Dali::PanGesture *)jarg2;
40776   if (!arg2) {
40777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40778     return 0;
40779   }
40780   {
40781     try {
40782       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
40783     } catch (std::out_of_range& e) {
40784       {
40785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40786       };
40787     } catch (std::exception& e) {
40788       {
40789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40790       };
40791     } catch (Dali::DaliException e) {
40792       {
40793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40794       };
40795     } catch (...) {
40796       {
40797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40798       };
40799     }
40800   }
40801
40802   jresult = (void *)result;
40803   return jresult;
40804 }
40805
40806
40807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
40808   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40809
40810   arg1 = (Dali::PanGesture *)jarg1;
40811   {
40812     try {
40813       delete arg1;
40814     } catch (std::out_of_range& e) {
40815       {
40816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40817       };
40818     } catch (std::exception& e) {
40819       {
40820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40821       };
40822     } catch (Dali::DaliException e) {
40823       {
40824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40825       };
40826     } catch (...) {
40827       {
40828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40829       };
40830     }
40831   }
40832
40833 }
40834
40835
40836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
40837   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40838   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40839
40840   arg1 = (Dali::PanGesture *)jarg1;
40841   arg2 = (Dali::Vector2 *)jarg2;
40842   if (arg1) (arg1)->velocity = *arg2;
40843 }
40844
40845
40846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
40847   void * jresult ;
40848   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40849   Dali::Vector2 *result = 0 ;
40850
40851   arg1 = (Dali::PanGesture *)jarg1;
40852   result = (Dali::Vector2 *)& ((arg1)->velocity);
40853   jresult = (void *)result;
40854   return jresult;
40855 }
40856
40857
40858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
40859   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40860   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40861
40862   arg1 = (Dali::PanGesture *)jarg1;
40863   arg2 = (Dali::Vector2 *)jarg2;
40864   if (arg1) (arg1)->displacement = *arg2;
40865 }
40866
40867
40868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
40869   void * jresult ;
40870   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40871   Dali::Vector2 *result = 0 ;
40872
40873   arg1 = (Dali::PanGesture *)jarg1;
40874   result = (Dali::Vector2 *)& ((arg1)->displacement);
40875   jresult = (void *)result;
40876   return jresult;
40877 }
40878
40879
40880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
40881   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40882   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40883
40884   arg1 = (Dali::PanGesture *)jarg1;
40885   arg2 = (Dali::Vector2 *)jarg2;
40886   if (arg1) (arg1)->position = *arg2;
40887 }
40888
40889
40890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
40891   void * jresult ;
40892   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40893   Dali::Vector2 *result = 0 ;
40894
40895   arg1 = (Dali::PanGesture *)jarg1;
40896   result = (Dali::Vector2 *)& ((arg1)->position);
40897   jresult = (void *)result;
40898   return jresult;
40899 }
40900
40901
40902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
40903   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40904   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40905
40906   arg1 = (Dali::PanGesture *)jarg1;
40907   arg2 = (Dali::Vector2 *)jarg2;
40908   if (arg1) (arg1)->screenVelocity = *arg2;
40909 }
40910
40911
40912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
40913   void * jresult ;
40914   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40915   Dali::Vector2 *result = 0 ;
40916
40917   arg1 = (Dali::PanGesture *)jarg1;
40918   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
40919   jresult = (void *)result;
40920   return jresult;
40921 }
40922
40923
40924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
40925   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40926   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40927
40928   arg1 = (Dali::PanGesture *)jarg1;
40929   arg2 = (Dali::Vector2 *)jarg2;
40930   if (arg1) (arg1)->screenDisplacement = *arg2;
40931 }
40932
40933
40934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
40935   void * jresult ;
40936   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40937   Dali::Vector2 *result = 0 ;
40938
40939   arg1 = (Dali::PanGesture *)jarg1;
40940   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
40941   jresult = (void *)result;
40942   return jresult;
40943 }
40944
40945
40946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
40947   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40948   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40949
40950   arg1 = (Dali::PanGesture *)jarg1;
40951   arg2 = (Dali::Vector2 *)jarg2;
40952   if (arg1) (arg1)->screenPosition = *arg2;
40953 }
40954
40955
40956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
40957   void * jresult ;
40958   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40959   Dali::Vector2 *result = 0 ;
40960
40961   arg1 = (Dali::PanGesture *)jarg1;
40962   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
40963   jresult = (void *)result;
40964   return jresult;
40965 }
40966
40967
40968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
40969   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40970   unsigned int arg2 ;
40971
40972   arg1 = (Dali::PanGesture *)jarg1;
40973   arg2 = (unsigned int)jarg2;
40974   if (arg1) (arg1)->numberOfTouches = arg2;
40975 }
40976
40977
40978 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
40979   unsigned int jresult ;
40980   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40981   unsigned int result;
40982
40983   arg1 = (Dali::PanGesture *)jarg1;
40984   result = (unsigned int) ((arg1)->numberOfTouches);
40985   jresult = result;
40986   return jresult;
40987 }
40988
40989
40990 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
40991   float jresult ;
40992   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40993   float result;
40994
40995   arg1 = (Dali::PanGesture *)jarg1;
40996   {
40997     try {
40998       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
40999     } catch (std::out_of_range& e) {
41000       {
41001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41002       };
41003     } catch (std::exception& e) {
41004       {
41005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41006       };
41007     } catch (Dali::DaliException e) {
41008       {
41009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41010       };
41011     } catch (...) {
41012       {
41013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41014       };
41015     }
41016   }
41017
41018   jresult = result;
41019   return jresult;
41020 }
41021
41022
41023 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41024   float jresult ;
41025   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41026   float result;
41027
41028   arg1 = (Dali::PanGesture *)jarg1;
41029   {
41030     try {
41031       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41032     } catch (std::out_of_range& e) {
41033       {
41034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41035       };
41036     } catch (std::exception& e) {
41037       {
41038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41039       };
41040     } catch (Dali::DaliException e) {
41041       {
41042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41043       };
41044     } catch (...) {
41045       {
41046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41047       };
41048     }
41049   }
41050
41051   jresult = result;
41052   return jresult;
41053 }
41054
41055
41056 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41057   float jresult ;
41058   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41059   float result;
41060
41061   arg1 = (Dali::PanGesture *)jarg1;
41062   {
41063     try {
41064       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41065     } catch (std::out_of_range& e) {
41066       {
41067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41068       };
41069     } catch (std::exception& e) {
41070       {
41071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41072       };
41073     } catch (Dali::DaliException e) {
41074       {
41075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41076       };
41077     } catch (...) {
41078       {
41079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41080       };
41081     }
41082   }
41083
41084   jresult = result;
41085   return jresult;
41086 }
41087
41088
41089 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41090   float jresult ;
41091   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41092   float result;
41093
41094   arg1 = (Dali::PanGesture *)jarg1;
41095   {
41096     try {
41097       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41098     } catch (std::out_of_range& e) {
41099       {
41100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41101       };
41102     } catch (std::exception& e) {
41103       {
41104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41105       };
41106     } catch (Dali::DaliException e) {
41107       {
41108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41109       };
41110     } catch (...) {
41111       {
41112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41113       };
41114     }
41115   }
41116
41117   jresult = result;
41118   return jresult;
41119 }
41120
41121
41122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41123   void * jresult ;
41124   Dali::PinchGestureDetector *result = 0 ;
41125
41126   {
41127     try {
41128       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41129     } catch (std::out_of_range& e) {
41130       {
41131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41132       };
41133     } catch (std::exception& e) {
41134       {
41135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41136       };
41137     } catch (Dali::DaliException e) {
41138       {
41139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41140       };
41141     } catch (...) {
41142       {
41143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41144       };
41145     }
41146   }
41147
41148   jresult = (void *)result;
41149   return jresult;
41150 }
41151
41152
41153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41154   void * jresult ;
41155   Dali::PinchGestureDetector result;
41156
41157   {
41158     try {
41159       result = Dali::PinchGestureDetector::New();
41160     } catch (std::out_of_range& e) {
41161       {
41162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41163       };
41164     } catch (std::exception& e) {
41165       {
41166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41167       };
41168     } catch (Dali::DaliException e) {
41169       {
41170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41171       };
41172     } catch (...) {
41173       {
41174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41175       };
41176     }
41177   }
41178
41179   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41180   return jresult;
41181 }
41182
41183
41184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41185   void * jresult ;
41186   Dali::BaseHandle arg1 ;
41187   Dali::BaseHandle *argp1 ;
41188   Dali::PinchGestureDetector result;
41189
41190   argp1 = (Dali::BaseHandle *)jarg1;
41191   if (!argp1) {
41192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41193     return 0;
41194   }
41195   arg1 = *argp1;
41196   {
41197     try {
41198       result = Dali::PinchGestureDetector::DownCast(arg1);
41199     } catch (std::out_of_range& e) {
41200       {
41201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41202       };
41203     } catch (std::exception& e) {
41204       {
41205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41206       };
41207     } catch (Dali::DaliException e) {
41208       {
41209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41210       };
41211     } catch (...) {
41212       {
41213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41214       };
41215     }
41216   }
41217
41218   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41219   return jresult;
41220 }
41221
41222
41223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41224   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41225
41226   arg1 = (Dali::PinchGestureDetector *)jarg1;
41227   {
41228     try {
41229       delete arg1;
41230     } catch (std::out_of_range& e) {
41231       {
41232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41233       };
41234     } catch (std::exception& e) {
41235       {
41236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41237       };
41238     } catch (Dali::DaliException e) {
41239       {
41240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41241       };
41242     } catch (...) {
41243       {
41244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41245       };
41246     }
41247   }
41248
41249 }
41250
41251
41252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41253   void * jresult ;
41254   Dali::PinchGestureDetector *arg1 = 0 ;
41255   Dali::PinchGestureDetector *result = 0 ;
41256
41257   arg1 = (Dali::PinchGestureDetector *)jarg1;
41258   if (!arg1) {
41259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41260     return 0;
41261   }
41262   {
41263     try {
41264       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41265     } catch (std::out_of_range& e) {
41266       {
41267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41268       };
41269     } catch (std::exception& e) {
41270       {
41271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41272       };
41273     } catch (Dali::DaliException e) {
41274       {
41275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41276       };
41277     } catch (...) {
41278       {
41279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41280       };
41281     }
41282   }
41283
41284   jresult = (void *)result;
41285   return jresult;
41286 }
41287
41288
41289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41290   void * jresult ;
41291   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41292   Dali::PinchGestureDetector *arg2 = 0 ;
41293   Dali::PinchGestureDetector *result = 0 ;
41294
41295   arg1 = (Dali::PinchGestureDetector *)jarg1;
41296   arg2 = (Dali::PinchGestureDetector *)jarg2;
41297   if (!arg2) {
41298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41299     return 0;
41300   }
41301   {
41302     try {
41303       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41304     } catch (std::out_of_range& e) {
41305       {
41306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41307       };
41308     } catch (std::exception& e) {
41309       {
41310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41311       };
41312     } catch (Dali::DaliException e) {
41313       {
41314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41315       };
41316     } catch (...) {
41317       {
41318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41319       };
41320     }
41321   }
41322
41323   jresult = (void *)result;
41324   return jresult;
41325 }
41326
41327
41328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41329   void * jresult ;
41330   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41331   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41332
41333   arg1 = (Dali::PinchGestureDetector *)jarg1;
41334   {
41335     try {
41336       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41337     } catch (std::out_of_range& e) {
41338       {
41339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41340       };
41341     } catch (std::exception& e) {
41342       {
41343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41344       };
41345     } catch (Dali::DaliException e) {
41346       {
41347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41348       };
41349     } catch (...) {
41350       {
41351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41352       };
41353     }
41354   }
41355
41356   jresult = (void *)result;
41357   return jresult;
41358 }
41359
41360
41361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41362   void * jresult ;
41363   Dali::Gesture::State arg1 ;
41364   Dali::PinchGesture *result = 0 ;
41365
41366   arg1 = (Dali::Gesture::State)jarg1;
41367   {
41368     try {
41369       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41370     } catch (std::out_of_range& e) {
41371       {
41372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41373       };
41374     } catch (std::exception& e) {
41375       {
41376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41377       };
41378     } catch (Dali::DaliException e) {
41379       {
41380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41381       };
41382     } catch (...) {
41383       {
41384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41385       };
41386     }
41387   }
41388
41389   jresult = (void *)result;
41390   return jresult;
41391 }
41392
41393
41394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41395   void * jresult ;
41396   Dali::PinchGesture *arg1 = 0 ;
41397   Dali::PinchGesture *result = 0 ;
41398
41399   arg1 = (Dali::PinchGesture *)jarg1;
41400   if (!arg1) {
41401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41402     return 0;
41403   }
41404   {
41405     try {
41406       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41407     } catch (std::out_of_range& e) {
41408       {
41409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41410       };
41411     } catch (std::exception& e) {
41412       {
41413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41414       };
41415     } catch (Dali::DaliException e) {
41416       {
41417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41418       };
41419     } catch (...) {
41420       {
41421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41422       };
41423     }
41424   }
41425
41426   jresult = (void *)result;
41427   return jresult;
41428 }
41429
41430
41431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
41432   void * jresult ;
41433   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41434   Dali::PinchGesture *arg2 = 0 ;
41435   Dali::PinchGesture *result = 0 ;
41436
41437   arg1 = (Dali::PinchGesture *)jarg1;
41438   arg2 = (Dali::PinchGesture *)jarg2;
41439   if (!arg2) {
41440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41441     return 0;
41442   }
41443   {
41444     try {
41445       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
41446     } catch (std::out_of_range& e) {
41447       {
41448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41449       };
41450     } catch (std::exception& e) {
41451       {
41452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41453       };
41454     } catch (Dali::DaliException e) {
41455       {
41456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41457       };
41458     } catch (...) {
41459       {
41460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41461       };
41462     }
41463   }
41464
41465   jresult = (void *)result;
41466   return jresult;
41467 }
41468
41469
41470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
41471   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41472
41473   arg1 = (Dali::PinchGesture *)jarg1;
41474   {
41475     try {
41476       delete arg1;
41477     } catch (std::out_of_range& e) {
41478       {
41479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41480       };
41481     } catch (std::exception& e) {
41482       {
41483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41484       };
41485     } catch (Dali::DaliException e) {
41486       {
41487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41488       };
41489     } catch (...) {
41490       {
41491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41492       };
41493     }
41494   }
41495
41496 }
41497
41498
41499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
41500   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41501   float arg2 ;
41502
41503   arg1 = (Dali::PinchGesture *)jarg1;
41504   arg2 = (float)jarg2;
41505   if (arg1) (arg1)->scale = arg2;
41506 }
41507
41508
41509 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
41510   float jresult ;
41511   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41512   float result;
41513
41514   arg1 = (Dali::PinchGesture *)jarg1;
41515   result = (float) ((arg1)->scale);
41516   jresult = result;
41517   return jresult;
41518 }
41519
41520
41521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
41522   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41523   float arg2 ;
41524
41525   arg1 = (Dali::PinchGesture *)jarg1;
41526   arg2 = (float)jarg2;
41527   if (arg1) (arg1)->speed = arg2;
41528 }
41529
41530
41531 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
41532   float jresult ;
41533   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41534   float result;
41535
41536   arg1 = (Dali::PinchGesture *)jarg1;
41537   result = (float) ((arg1)->speed);
41538   jresult = result;
41539   return jresult;
41540 }
41541
41542
41543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
41544   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41545   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41546
41547   arg1 = (Dali::PinchGesture *)jarg1;
41548   arg2 = (Dali::Vector2 *)jarg2;
41549   if (arg1) (arg1)->screenCenterPoint = *arg2;
41550 }
41551
41552
41553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
41554   void * jresult ;
41555   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41556   Dali::Vector2 *result = 0 ;
41557
41558   arg1 = (Dali::PinchGesture *)jarg1;
41559   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
41560   jresult = (void *)result;
41561   return jresult;
41562 }
41563
41564
41565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
41566   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41567   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41568
41569   arg1 = (Dali::PinchGesture *)jarg1;
41570   arg2 = (Dali::Vector2 *)jarg2;
41571   if (arg1) (arg1)->localCenterPoint = *arg2;
41572 }
41573
41574
41575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
41576   void * jresult ;
41577   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41578   Dali::Vector2 *result = 0 ;
41579
41580   arg1 = (Dali::PinchGesture *)jarg1;
41581   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
41582   jresult = (void *)result;
41583   return jresult;
41584 }
41585
41586
41587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
41588   void * jresult ;
41589   Dali::TapGestureDetector *result = 0 ;
41590
41591   {
41592     try {
41593       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
41594     } catch (std::out_of_range& e) {
41595       {
41596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41597       };
41598     } catch (std::exception& e) {
41599       {
41600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41601       };
41602     } catch (Dali::DaliException e) {
41603       {
41604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41605       };
41606     } catch (...) {
41607       {
41608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41609       };
41610     }
41611   }
41612
41613   jresult = (void *)result;
41614   return jresult;
41615 }
41616
41617
41618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
41619   void * jresult ;
41620   Dali::TapGestureDetector result;
41621
41622   {
41623     try {
41624       result = Dali::TapGestureDetector::New();
41625     } catch (std::out_of_range& e) {
41626       {
41627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41628       };
41629     } catch (std::exception& e) {
41630       {
41631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41632       };
41633     } catch (Dali::DaliException e) {
41634       {
41635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41636       };
41637     } catch (...) {
41638       {
41639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41640       };
41641     }
41642   }
41643
41644   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41645   return jresult;
41646 }
41647
41648
41649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
41650   void * jresult ;
41651   unsigned int arg1 ;
41652   Dali::TapGestureDetector result;
41653
41654   arg1 = (unsigned int)jarg1;
41655   {
41656     try {
41657       result = Dali::TapGestureDetector::New(arg1);
41658     } catch (std::out_of_range& e) {
41659       {
41660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41661       };
41662     } catch (std::exception& e) {
41663       {
41664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41665       };
41666     } catch (Dali::DaliException e) {
41667       {
41668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41669       };
41670     } catch (...) {
41671       {
41672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41673       };
41674     }
41675   }
41676
41677   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41678   return jresult;
41679 }
41680
41681
41682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
41683   void * jresult ;
41684   Dali::BaseHandle arg1 ;
41685   Dali::BaseHandle *argp1 ;
41686   Dali::TapGestureDetector result;
41687
41688   argp1 = (Dali::BaseHandle *)jarg1;
41689   if (!argp1) {
41690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41691     return 0;
41692   }
41693   arg1 = *argp1;
41694   {
41695     try {
41696       result = Dali::TapGestureDetector::DownCast(arg1);
41697     } catch (std::out_of_range& e) {
41698       {
41699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41700       };
41701     } catch (std::exception& e) {
41702       {
41703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41704       };
41705     } catch (Dali::DaliException e) {
41706       {
41707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41708       };
41709     } catch (...) {
41710       {
41711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41712       };
41713     }
41714   }
41715
41716   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41717   return jresult;
41718 }
41719
41720
41721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
41722   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41723
41724   arg1 = (Dali::TapGestureDetector *)jarg1;
41725   {
41726     try {
41727       delete arg1;
41728     } catch (std::out_of_range& e) {
41729       {
41730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41731       };
41732     } catch (std::exception& e) {
41733       {
41734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41735       };
41736     } catch (Dali::DaliException e) {
41737       {
41738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41739       };
41740     } catch (...) {
41741       {
41742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41743       };
41744     }
41745   }
41746
41747 }
41748
41749
41750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
41751   void * jresult ;
41752   Dali::TapGestureDetector *arg1 = 0 ;
41753   Dali::TapGestureDetector *result = 0 ;
41754
41755   arg1 = (Dali::TapGestureDetector *)jarg1;
41756   if (!arg1) {
41757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41758     return 0;
41759   }
41760   {
41761     try {
41762       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
41763     } catch (std::out_of_range& e) {
41764       {
41765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41766       };
41767     } catch (std::exception& e) {
41768       {
41769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41770       };
41771     } catch (Dali::DaliException e) {
41772       {
41773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41774       };
41775     } catch (...) {
41776       {
41777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41778       };
41779     }
41780   }
41781
41782   jresult = (void *)result;
41783   return jresult;
41784 }
41785
41786
41787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
41788   void * jresult ;
41789   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41790   Dali::TapGestureDetector *arg2 = 0 ;
41791   Dali::TapGestureDetector *result = 0 ;
41792
41793   arg1 = (Dali::TapGestureDetector *)jarg1;
41794   arg2 = (Dali::TapGestureDetector *)jarg2;
41795   if (!arg2) {
41796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41797     return 0;
41798   }
41799   {
41800     try {
41801       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
41802     } catch (std::out_of_range& e) {
41803       {
41804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41805       };
41806     } catch (std::exception& e) {
41807       {
41808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41809       };
41810     } catch (Dali::DaliException e) {
41811       {
41812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41813       };
41814     } catch (...) {
41815       {
41816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41817       };
41818     }
41819   }
41820
41821   jresult = (void *)result;
41822   return jresult;
41823 }
41824
41825
41826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
41827   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41828   unsigned int arg2 ;
41829
41830   arg1 = (Dali::TapGestureDetector *)jarg1;
41831   arg2 = (unsigned int)jarg2;
41832   {
41833     try {
41834       (arg1)->SetMinimumTapsRequired(arg2);
41835     } catch (std::out_of_range& e) {
41836       {
41837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41838       };
41839     } catch (std::exception& e) {
41840       {
41841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41842       };
41843     } catch (Dali::DaliException e) {
41844       {
41845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41846       };
41847     } catch (...) {
41848       {
41849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41850       };
41851     }
41852   }
41853
41854 }
41855
41856
41857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
41858   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41859   unsigned int arg2 ;
41860
41861   arg1 = (Dali::TapGestureDetector *)jarg1;
41862   arg2 = (unsigned int)jarg2;
41863   {
41864     try {
41865       (arg1)->SetMaximumTapsRequired(arg2);
41866     } catch (std::out_of_range& e) {
41867       {
41868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41869       };
41870     } catch (std::exception& e) {
41871       {
41872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41873       };
41874     } catch (Dali::DaliException e) {
41875       {
41876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41877       };
41878     } catch (...) {
41879       {
41880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41881       };
41882     }
41883   }
41884
41885 }
41886
41887
41888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
41889   unsigned int jresult ;
41890   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41891   unsigned int result;
41892
41893   arg1 = (Dali::TapGestureDetector *)jarg1;
41894   {
41895     try {
41896       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
41897     } catch (std::out_of_range& e) {
41898       {
41899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41900       };
41901     } catch (std::exception& e) {
41902       {
41903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41904       };
41905     } catch (Dali::DaliException e) {
41906       {
41907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41908       };
41909     } catch (...) {
41910       {
41911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41912       };
41913     }
41914   }
41915
41916   jresult = result;
41917   return jresult;
41918 }
41919
41920
41921 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
41922   unsigned int jresult ;
41923   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41924   unsigned int result;
41925
41926   arg1 = (Dali::TapGestureDetector *)jarg1;
41927   {
41928     try {
41929       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
41930     } catch (std::out_of_range& e) {
41931       {
41932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41933       };
41934     } catch (std::exception& e) {
41935       {
41936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41937       };
41938     } catch (Dali::DaliException e) {
41939       {
41940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41941       };
41942     } catch (...) {
41943       {
41944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41945       };
41946     }
41947   }
41948
41949   jresult = result;
41950   return jresult;
41951 }
41952
41953
41954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
41955   void * jresult ;
41956   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41957   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
41958
41959   arg1 = (Dali::TapGestureDetector *)jarg1;
41960   {
41961     try {
41962       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41963     } catch (std::out_of_range& e) {
41964       {
41965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41966       };
41967     } catch (std::exception& e) {
41968       {
41969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41970       };
41971     } catch (Dali::DaliException e) {
41972       {
41973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41974       };
41975     } catch (...) {
41976       {
41977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41978       };
41979     }
41980   }
41981
41982   jresult = (void *)result;
41983   return jresult;
41984 }
41985
41986
41987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
41988   void * jresult ;
41989   Dali::TapGesture *result = 0 ;
41990
41991   {
41992     try {
41993       result = (Dali::TapGesture *)new Dali::TapGesture();
41994     } catch (std::out_of_range& e) {
41995       {
41996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41997       };
41998     } catch (std::exception& e) {
41999       {
42000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42001       };
42002     } catch (Dali::DaliException e) {
42003       {
42004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42005       };
42006     } catch (...) {
42007       {
42008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42009       };
42010     }
42011   }
42012
42013   jresult = (void *)result;
42014   return jresult;
42015 }
42016
42017
42018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42019   void * jresult ;
42020   Dali::TapGesture *arg1 = 0 ;
42021   Dali::TapGesture *result = 0 ;
42022
42023   arg1 = (Dali::TapGesture *)jarg1;
42024   if (!arg1) {
42025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42026     return 0;
42027   }
42028   {
42029     try {
42030       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42031     } catch (std::out_of_range& e) {
42032       {
42033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42034       };
42035     } catch (std::exception& e) {
42036       {
42037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42038       };
42039     } catch (Dali::DaliException e) {
42040       {
42041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42042       };
42043     } catch (...) {
42044       {
42045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42046       };
42047     }
42048   }
42049
42050   jresult = (void *)result;
42051   return jresult;
42052 }
42053
42054
42055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42056   void * jresult ;
42057   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42058   Dali::TapGesture *arg2 = 0 ;
42059   Dali::TapGesture *result = 0 ;
42060
42061   arg1 = (Dali::TapGesture *)jarg1;
42062   arg2 = (Dali::TapGesture *)jarg2;
42063   if (!arg2) {
42064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42065     return 0;
42066   }
42067   {
42068     try {
42069       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42070     } catch (std::out_of_range& e) {
42071       {
42072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42073       };
42074     } catch (std::exception& e) {
42075       {
42076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42077       };
42078     } catch (Dali::DaliException e) {
42079       {
42080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42081       };
42082     } catch (...) {
42083       {
42084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42085       };
42086     }
42087   }
42088
42089   jresult = (void *)result;
42090   return jresult;
42091 }
42092
42093
42094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42095   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42096
42097   arg1 = (Dali::TapGesture *)jarg1;
42098   {
42099     try {
42100       delete arg1;
42101     } catch (std::out_of_range& e) {
42102       {
42103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42104       };
42105     } catch (std::exception& e) {
42106       {
42107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42108       };
42109     } catch (Dali::DaliException e) {
42110       {
42111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42112       };
42113     } catch (...) {
42114       {
42115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42116       };
42117     }
42118   }
42119
42120 }
42121
42122
42123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42124   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42125   unsigned int arg2 ;
42126
42127   arg1 = (Dali::TapGesture *)jarg1;
42128   arg2 = (unsigned int)jarg2;
42129   if (arg1) (arg1)->numberOfTaps = arg2;
42130 }
42131
42132
42133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42134   unsigned int jresult ;
42135   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42136   unsigned int result;
42137
42138   arg1 = (Dali::TapGesture *)jarg1;
42139   result = (unsigned int) ((arg1)->numberOfTaps);
42140   jresult = result;
42141   return jresult;
42142 }
42143
42144
42145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42146   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42147   unsigned int arg2 ;
42148
42149   arg1 = (Dali::TapGesture *)jarg1;
42150   arg2 = (unsigned int)jarg2;
42151   if (arg1) (arg1)->numberOfTouches = arg2;
42152 }
42153
42154
42155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42156   unsigned int jresult ;
42157   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42158   unsigned int result;
42159
42160   arg1 = (Dali::TapGesture *)jarg1;
42161   result = (unsigned int) ((arg1)->numberOfTouches);
42162   jresult = result;
42163   return jresult;
42164 }
42165
42166
42167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42168   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42169   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42170
42171   arg1 = (Dali::TapGesture *)jarg1;
42172   arg2 = (Dali::Vector2 *)jarg2;
42173   if (arg1) (arg1)->screenPoint = *arg2;
42174 }
42175
42176
42177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42178   void * jresult ;
42179   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42180   Dali::Vector2 *result = 0 ;
42181
42182   arg1 = (Dali::TapGesture *)jarg1;
42183   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42184   jresult = (void *)result;
42185   return jresult;
42186 }
42187
42188
42189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42190   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42191   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42192
42193   arg1 = (Dali::TapGesture *)jarg1;
42194   arg2 = (Dali::Vector2 *)jarg2;
42195   if (arg1) (arg1)->localPoint = *arg2;
42196 }
42197
42198
42199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42200   void * jresult ;
42201   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42202   Dali::Vector2 *result = 0 ;
42203
42204   arg1 = (Dali::TapGesture *)jarg1;
42205   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42206   jresult = (void *)result;
42207   return jresult;
42208 }
42209
42210
42211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42212   void * jresult ;
42213   Dali::AlphaFunction *result = 0 ;
42214
42215   {
42216     try {
42217       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42218     } catch (std::out_of_range& e) {
42219       {
42220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42221       };
42222     } catch (std::exception& e) {
42223       {
42224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42225       };
42226     } catch (Dali::DaliException e) {
42227       {
42228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42229       };
42230     } catch (...) {
42231       {
42232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42233       };
42234     }
42235   }
42236
42237   jresult = (void *)result;
42238   return jresult;
42239 }
42240
42241
42242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42243   void * jresult ;
42244   Dali::AlphaFunction::BuiltinFunction arg1 ;
42245   Dali::AlphaFunction *result = 0 ;
42246
42247   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42248   {
42249     try {
42250       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42251     } catch (std::out_of_range& e) {
42252       {
42253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42254       };
42255     } catch (std::exception& e) {
42256       {
42257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42258       };
42259     } catch (Dali::DaliException e) {
42260       {
42261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42262       };
42263     } catch (...) {
42264       {
42265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42266       };
42267     }
42268   }
42269
42270   jresult = (void *)result;
42271   return jresult;
42272 }
42273
42274
42275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42276   void * jresult ;
42277   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42278   Dali::AlphaFunction *result = 0 ;
42279
42280   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42281   {
42282     try {
42283       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42284     } catch (std::out_of_range& e) {
42285       {
42286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42287       };
42288     } catch (std::exception& e) {
42289       {
42290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42291       };
42292     } catch (Dali::DaliException e) {
42293       {
42294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42295       };
42296     } catch (...) {
42297       {
42298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42299       };
42300     }
42301   }
42302
42303   jresult = (void *)result;
42304   return jresult;
42305 }
42306
42307
42308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42309   void * jresult ;
42310   Dali::Vector2 *arg1 = 0 ;
42311   Dali::Vector2 *arg2 = 0 ;
42312   Dali::AlphaFunction *result = 0 ;
42313
42314   arg1 = (Dali::Vector2 *)jarg1;
42315   if (!arg1) {
42316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42317     return 0;
42318   }
42319   arg2 = (Dali::Vector2 *)jarg2;
42320   if (!arg2) {
42321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42322     return 0;
42323   }
42324   {
42325     try {
42326       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42327     } catch (std::out_of_range& e) {
42328       {
42329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42330       };
42331     } catch (std::exception& e) {
42332       {
42333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42334       };
42335     } catch (Dali::DaliException e) {
42336       {
42337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42338       };
42339     } catch (...) {
42340       {
42341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42342       };
42343     }
42344   }
42345
42346   jresult = (void *)result;
42347   return jresult;
42348 }
42349
42350
42351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42352   void * jresult ;
42353   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42354   Dali::Vector4 result;
42355
42356   arg1 = (Dali::AlphaFunction *)jarg1;
42357   {
42358     try {
42359       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42360     } catch (std::out_of_range& e) {
42361       {
42362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42363       };
42364     } catch (std::exception& e) {
42365       {
42366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42367       };
42368     } catch (Dali::DaliException e) {
42369       {
42370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42371       };
42372     } catch (...) {
42373       {
42374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42375       };
42376     }
42377   }
42378
42379   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42380   return jresult;
42381 }
42382
42383
42384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42385   void * jresult ;
42386   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42387   Dali::AlphaFunctionPrototype result;
42388
42389   arg1 = (Dali::AlphaFunction *)jarg1;
42390   {
42391     try {
42392       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42393     } catch (std::out_of_range& e) {
42394       {
42395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42396       };
42397     } catch (std::exception& e) {
42398       {
42399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42400       };
42401     } catch (Dali::DaliException e) {
42402       {
42403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42404       };
42405     } catch (...) {
42406       {
42407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42408       };
42409     }
42410   }
42411
42412   jresult = (void *)result;
42413   return jresult;
42414 }
42415
42416
42417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42418   int jresult ;
42419   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42420   Dali::AlphaFunction::BuiltinFunction result;
42421
42422   arg1 = (Dali::AlphaFunction *)jarg1;
42423   {
42424     try {
42425       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
42426     } catch (std::out_of_range& e) {
42427       {
42428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42429       };
42430     } catch (std::exception& e) {
42431       {
42432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42433       };
42434     } catch (Dali::DaliException e) {
42435       {
42436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42437       };
42438     } catch (...) {
42439       {
42440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42441       };
42442     }
42443   }
42444
42445   jresult = (int)result;
42446   return jresult;
42447 }
42448
42449
42450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
42451   int jresult ;
42452   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42453   Dali::AlphaFunction::Mode result;
42454
42455   arg1 = (Dali::AlphaFunction *)jarg1;
42456   {
42457     try {
42458       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
42459     } catch (std::out_of_range& e) {
42460       {
42461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42462       };
42463     } catch (std::exception& e) {
42464       {
42465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42466       };
42467     } catch (Dali::DaliException e) {
42468       {
42469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42470       };
42471     } catch (...) {
42472       {
42473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42474       };
42475     }
42476   }
42477
42478   jresult = (int)result;
42479   return jresult;
42480 }
42481
42482
42483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
42484   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42485
42486   arg1 = (Dali::AlphaFunction *)jarg1;
42487   {
42488     try {
42489       delete arg1;
42490     } catch (std::out_of_range& e) {
42491       {
42492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42493       };
42494     } catch (std::exception& e) {
42495       {
42496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42497       };
42498     } catch (Dali::DaliException e) {
42499       {
42500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42501       };
42502     } catch (...) {
42503       {
42504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42505       };
42506     }
42507   }
42508
42509 }
42510
42511
42512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
42513   void * jresult ;
42514   Dali::KeyFrames result;
42515
42516   {
42517     try {
42518       result = Dali::KeyFrames::New();
42519     } catch (std::out_of_range& e) {
42520       {
42521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42522       };
42523     } catch (std::exception& e) {
42524       {
42525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42526       };
42527     } catch (Dali::DaliException e) {
42528       {
42529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42530       };
42531     } catch (...) {
42532       {
42533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42534       };
42535     }
42536   }
42537
42538   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42539   return jresult;
42540 }
42541
42542
42543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
42544   void * jresult ;
42545   Dali::BaseHandle arg1 ;
42546   Dali::BaseHandle *argp1 ;
42547   Dali::KeyFrames result;
42548
42549   argp1 = (Dali::BaseHandle *)jarg1;
42550   if (!argp1) {
42551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42552     return 0;
42553   }
42554   arg1 = *argp1;
42555   {
42556     try {
42557       result = Dali::KeyFrames::DownCast(arg1);
42558     } catch (std::out_of_range& e) {
42559       {
42560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42561       };
42562     } catch (std::exception& e) {
42563       {
42564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42565       };
42566     } catch (Dali::DaliException e) {
42567       {
42568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42569       };
42570     } catch (...) {
42571       {
42572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42573       };
42574     }
42575   }
42576
42577   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42578   return jresult;
42579 }
42580
42581
42582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
42583   void * jresult ;
42584   Dali::KeyFrames *result = 0 ;
42585
42586   {
42587     try {
42588       result = (Dali::KeyFrames *)new Dali::KeyFrames();
42589     } catch (std::out_of_range& e) {
42590       {
42591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42592       };
42593     } catch (std::exception& e) {
42594       {
42595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42596       };
42597     } catch (Dali::DaliException e) {
42598       {
42599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42600       };
42601     } catch (...) {
42602       {
42603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42604       };
42605     }
42606   }
42607
42608   jresult = (void *)result;
42609   return jresult;
42610 }
42611
42612
42613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
42614   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42615
42616   arg1 = (Dali::KeyFrames *)jarg1;
42617   {
42618     try {
42619       delete arg1;
42620     } catch (std::out_of_range& e) {
42621       {
42622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42623       };
42624     } catch (std::exception& e) {
42625       {
42626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42627       };
42628     } catch (Dali::DaliException e) {
42629       {
42630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42631       };
42632     } catch (...) {
42633       {
42634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42635       };
42636     }
42637   }
42638
42639 }
42640
42641
42642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
42643   void * jresult ;
42644   Dali::KeyFrames *arg1 = 0 ;
42645   Dali::KeyFrames *result = 0 ;
42646
42647   arg1 = (Dali::KeyFrames *)jarg1;
42648   if (!arg1) {
42649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42650     return 0;
42651   }
42652   {
42653     try {
42654       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
42655     } catch (std::out_of_range& e) {
42656       {
42657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42658       };
42659     } catch (std::exception& e) {
42660       {
42661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42662       };
42663     } catch (Dali::DaliException e) {
42664       {
42665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42666       };
42667     } catch (...) {
42668       {
42669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42670       };
42671     }
42672   }
42673
42674   jresult = (void *)result;
42675   return jresult;
42676 }
42677
42678
42679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
42680   void * jresult ;
42681   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42682   Dali::KeyFrames *arg2 = 0 ;
42683   Dali::KeyFrames *result = 0 ;
42684
42685   arg1 = (Dali::KeyFrames *)jarg1;
42686   arg2 = (Dali::KeyFrames *)jarg2;
42687   if (!arg2) {
42688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42689     return 0;
42690   }
42691   {
42692     try {
42693       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
42694     } catch (std::out_of_range& e) {
42695       {
42696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42697       };
42698     } catch (std::exception& e) {
42699       {
42700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42701       };
42702     } catch (Dali::DaliException e) {
42703       {
42704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42705       };
42706     } catch (...) {
42707       {
42708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42709       };
42710     }
42711   }
42712
42713   jresult = (void *)result;
42714   return jresult;
42715 }
42716
42717
42718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
42719   int jresult ;
42720   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42721   Dali::Property::Type result;
42722
42723   arg1 = (Dali::KeyFrames *)jarg1;
42724   {
42725     try {
42726       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
42727     } catch (std::out_of_range& e) {
42728       {
42729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42730       };
42731     } catch (std::exception& e) {
42732       {
42733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42734       };
42735     } catch (Dali::DaliException e) {
42736       {
42737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42738       };
42739     } catch (...) {
42740       {
42741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42742       };
42743     }
42744   }
42745
42746   jresult = (int)result;
42747   return jresult;
42748 }
42749
42750
42751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
42752   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42753   float arg2 ;
42754   Dali::Property::Value arg3 ;
42755   Dali::Property::Value *argp3 ;
42756
42757   arg1 = (Dali::KeyFrames *)jarg1;
42758   arg2 = (float)jarg2;
42759   argp3 = (Dali::Property::Value *)jarg3;
42760   if (!argp3) {
42761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42762     return ;
42763   }
42764   arg3 = *argp3;
42765   {
42766     try {
42767       (arg1)->Add(arg2,arg3);
42768     } catch (std::out_of_range& e) {
42769       {
42770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42771       };
42772     } catch (std::exception& e) {
42773       {
42774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42775       };
42776     } catch (Dali::DaliException e) {
42777       {
42778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42779       };
42780     } catch (...) {
42781       {
42782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42783       };
42784     }
42785   }
42786
42787 }
42788
42789
42790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
42791   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42792   float arg2 ;
42793   Dali::Property::Value arg3 ;
42794   Dali::AlphaFunction arg4 ;
42795   Dali::Property::Value *argp3 ;
42796   Dali::AlphaFunction *argp4 ;
42797
42798   arg1 = (Dali::KeyFrames *)jarg1;
42799   arg2 = (float)jarg2;
42800   argp3 = (Dali::Property::Value *)jarg3;
42801   if (!argp3) {
42802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42803     return ;
42804   }
42805   arg3 = *argp3;
42806   argp4 = (Dali::AlphaFunction *)jarg4;
42807   if (!argp4) {
42808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
42809     return ;
42810   }
42811   arg4 = *argp4;
42812   {
42813     try {
42814       (arg1)->Add(arg2,arg3,arg4);
42815     } catch (std::out_of_range& e) {
42816       {
42817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42818       };
42819     } catch (std::exception& e) {
42820       {
42821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42822       };
42823     } catch (Dali::DaliException e) {
42824       {
42825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42826       };
42827     } catch (...) {
42828       {
42829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42830       };
42831     }
42832   }
42833
42834 }
42835
42836
42837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
42838   int jresult ;
42839   int result;
42840
42841   result = (int)Dali::Path::Property::POINTS;
42842   jresult = (int)result;
42843   return jresult;
42844 }
42845
42846
42847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
42848   int jresult ;
42849   int result;
42850
42851   result = (int)Dali::Path::Property::CONTROL_POINTS;
42852   jresult = (int)result;
42853   return jresult;
42854 }
42855
42856
42857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
42858   void * jresult ;
42859   Dali::Path::Property *result = 0 ;
42860
42861   {
42862     try {
42863       result = (Dali::Path::Property *)new Dali::Path::Property();
42864     } catch (std::out_of_range& e) {
42865       {
42866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42867       };
42868     } catch (std::exception& e) {
42869       {
42870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42871       };
42872     } catch (Dali::DaliException e) {
42873       {
42874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42875       };
42876     } catch (...) {
42877       {
42878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42879       };
42880     }
42881   }
42882
42883   jresult = (void *)result;
42884   return jresult;
42885 }
42886
42887
42888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
42889   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
42890
42891   arg1 = (Dali::Path::Property *)jarg1;
42892   {
42893     try {
42894       delete arg1;
42895     } catch (std::out_of_range& e) {
42896       {
42897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42898       };
42899     } catch (std::exception& e) {
42900       {
42901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42902       };
42903     } catch (Dali::DaliException e) {
42904       {
42905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42906       };
42907     } catch (...) {
42908       {
42909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42910       };
42911     }
42912   }
42913
42914 }
42915
42916
42917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
42918   void * jresult ;
42919   Dali::Path result;
42920
42921   {
42922     try {
42923       result = Dali::Path::New();
42924     } catch (std::out_of_range& e) {
42925       {
42926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42927       };
42928     } catch (std::exception& e) {
42929       {
42930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42931       };
42932     } catch (Dali::DaliException e) {
42933       {
42934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42935       };
42936     } catch (...) {
42937       {
42938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42939       };
42940     }
42941   }
42942
42943   jresult = new Dali::Path((const Dali::Path &)result);
42944   return jresult;
42945 }
42946
42947
42948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
42949   void * jresult ;
42950   Dali::BaseHandle arg1 ;
42951   Dali::BaseHandle *argp1 ;
42952   Dali::Path result;
42953
42954   argp1 = (Dali::BaseHandle *)jarg1;
42955   if (!argp1) {
42956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42957     return 0;
42958   }
42959   arg1 = *argp1;
42960   {
42961     try {
42962       result = Dali::Path::DownCast(arg1);
42963     } catch (std::out_of_range& e) {
42964       {
42965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42966       };
42967     } catch (std::exception& e) {
42968       {
42969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42970       };
42971     } catch (Dali::DaliException e) {
42972       {
42973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42974       };
42975     } catch (...) {
42976       {
42977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42978       };
42979     }
42980   }
42981
42982   jresult = new Dali::Path((const Dali::Path &)result);
42983   return jresult;
42984 }
42985
42986
42987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
42988   void * jresult ;
42989   Dali::Path *result = 0 ;
42990
42991   {
42992     try {
42993       result = (Dali::Path *)new Dali::Path();
42994     } catch (std::out_of_range& e) {
42995       {
42996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42997       };
42998     } catch (std::exception& e) {
42999       {
43000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43001       };
43002     } catch (Dali::DaliException e) {
43003       {
43004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43005       };
43006     } catch (...) {
43007       {
43008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43009       };
43010     }
43011   }
43012
43013   jresult = (void *)result;
43014   return jresult;
43015 }
43016
43017
43018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43019   Dali::Path *arg1 = (Dali::Path *) 0 ;
43020
43021   arg1 = (Dali::Path *)jarg1;
43022   {
43023     try {
43024       delete arg1;
43025     } catch (std::out_of_range& e) {
43026       {
43027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43028       };
43029     } catch (std::exception& e) {
43030       {
43031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43032       };
43033     } catch (Dali::DaliException e) {
43034       {
43035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43036       };
43037     } catch (...) {
43038       {
43039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43040       };
43041     }
43042   }
43043
43044 }
43045
43046
43047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43048   void * jresult ;
43049   Dali::Path *arg1 = 0 ;
43050   Dali::Path *result = 0 ;
43051
43052   arg1 = (Dali::Path *)jarg1;
43053   if (!arg1) {
43054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43055     return 0;
43056   }
43057   {
43058     try {
43059       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43060     } catch (std::out_of_range& e) {
43061       {
43062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43063       };
43064     } catch (std::exception& e) {
43065       {
43066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43067       };
43068     } catch (Dali::DaliException e) {
43069       {
43070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43071       };
43072     } catch (...) {
43073       {
43074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43075       };
43076     }
43077   }
43078
43079   jresult = (void *)result;
43080   return jresult;
43081 }
43082
43083
43084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43085   void * jresult ;
43086   Dali::Path *arg1 = (Dali::Path *) 0 ;
43087   Dali::Path *arg2 = 0 ;
43088   Dali::Path *result = 0 ;
43089
43090   arg1 = (Dali::Path *)jarg1;
43091   arg2 = (Dali::Path *)jarg2;
43092   if (!arg2) {
43093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43094     return 0;
43095   }
43096   {
43097     try {
43098       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43099     } catch (std::out_of_range& e) {
43100       {
43101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43102       };
43103     } catch (std::exception& e) {
43104       {
43105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43106       };
43107     } catch (Dali::DaliException e) {
43108       {
43109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43110       };
43111     } catch (...) {
43112       {
43113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43114       };
43115     }
43116   }
43117
43118   jresult = (void *)result;
43119   return jresult;
43120 }
43121
43122
43123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43124   Dali::Path *arg1 = (Dali::Path *) 0 ;
43125   Dali::Vector3 *arg2 = 0 ;
43126
43127   arg1 = (Dali::Path *)jarg1;
43128   arg2 = (Dali::Vector3 *)jarg2;
43129   if (!arg2) {
43130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43131     return ;
43132   }
43133   {
43134     try {
43135       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43136     } catch (std::out_of_range& e) {
43137       {
43138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43139       };
43140     } catch (std::exception& e) {
43141       {
43142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43143       };
43144     } catch (Dali::DaliException e) {
43145       {
43146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43147       };
43148     } catch (...) {
43149       {
43150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43151       };
43152     }
43153   }
43154
43155 }
43156
43157
43158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43159   Dali::Path *arg1 = (Dali::Path *) 0 ;
43160   Dali::Vector3 *arg2 = 0 ;
43161
43162   arg1 = (Dali::Path *)jarg1;
43163   arg2 = (Dali::Vector3 *)jarg2;
43164   if (!arg2) {
43165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43166     return ;
43167   }
43168   {
43169     try {
43170       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43171     } catch (std::out_of_range& e) {
43172       {
43173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43174       };
43175     } catch (std::exception& e) {
43176       {
43177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43178       };
43179     } catch (Dali::DaliException e) {
43180       {
43181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43182       };
43183     } catch (...) {
43184       {
43185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43186       };
43187     }
43188   }
43189
43190 }
43191
43192
43193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43194   Dali::Path *arg1 = (Dali::Path *) 0 ;
43195   float arg2 ;
43196
43197   arg1 = (Dali::Path *)jarg1;
43198   arg2 = (float)jarg2;
43199   {
43200     try {
43201       (arg1)->GenerateControlPoints(arg2);
43202     } catch (std::out_of_range& e) {
43203       {
43204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43205       };
43206     } catch (std::exception& e) {
43207       {
43208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43209       };
43210     } catch (Dali::DaliException e) {
43211       {
43212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43213       };
43214     } catch (...) {
43215       {
43216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43217       };
43218     }
43219   }
43220
43221 }
43222
43223
43224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43225   Dali::Path *arg1 = (Dali::Path *) 0 ;
43226   float arg2 ;
43227   Dali::Vector3 *arg3 = 0 ;
43228   Dali::Vector3 *arg4 = 0 ;
43229
43230   arg1 = (Dali::Path *)jarg1;
43231   arg2 = (float)jarg2;
43232   arg3 = (Dali::Vector3 *)jarg3;
43233   if (!arg3) {
43234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43235     return ;
43236   }
43237   arg4 = (Dali::Vector3 *)jarg4;
43238   if (!arg4) {
43239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43240     return ;
43241   }
43242   {
43243     try {
43244       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43245     } catch (std::out_of_range& e) {
43246       {
43247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43248       };
43249     } catch (std::exception& e) {
43250       {
43251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43252       };
43253     } catch (Dali::DaliException e) {
43254       {
43255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43256       };
43257     } catch (...) {
43258       {
43259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43260       };
43261     }
43262   }
43263
43264 }
43265
43266
43267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43268   void * jresult ;
43269   Dali::Path *arg1 = (Dali::Path *) 0 ;
43270   size_t arg2 ;
43271   Dali::Vector3 *result = 0 ;
43272
43273   arg1 = (Dali::Path *)jarg1;
43274   arg2 = (size_t)jarg2;
43275   {
43276     try {
43277       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43278     } catch (std::out_of_range& e) {
43279       {
43280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43281       };
43282     } catch (std::exception& e) {
43283       {
43284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43285       };
43286     } catch (Dali::DaliException e) {
43287       {
43288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43289       };
43290     } catch (...) {
43291       {
43292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43293       };
43294     }
43295   }
43296
43297   jresult = (void *)result;
43298   return jresult;
43299 }
43300
43301
43302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43303   void * jresult ;
43304   Dali::Path *arg1 = (Dali::Path *) 0 ;
43305   size_t arg2 ;
43306   Dali::Vector3 *result = 0 ;
43307
43308   arg1 = (Dali::Path *)jarg1;
43309   arg2 = (size_t)jarg2;
43310   {
43311     try {
43312       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43313     } catch (std::out_of_range& e) {
43314       {
43315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43316       };
43317     } catch (std::exception& e) {
43318       {
43319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43320       };
43321     } catch (Dali::DaliException e) {
43322       {
43323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43324       };
43325     } catch (...) {
43326       {
43327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43328       };
43329     }
43330   }
43331
43332   jresult = (void *)result;
43333   return jresult;
43334 }
43335
43336
43337 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43338   unsigned long jresult ;
43339   Dali::Path *arg1 = (Dali::Path *) 0 ;
43340   size_t result;
43341
43342   arg1 = (Dali::Path *)jarg1;
43343   {
43344     try {
43345       result = ((Dali::Path const *)arg1)->GetPointCount();
43346     } catch (std::out_of_range& e) {
43347       {
43348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43349       };
43350     } catch (std::exception& e) {
43351       {
43352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43353       };
43354     } catch (Dali::DaliException e) {
43355       {
43356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43357       };
43358     } catch (...) {
43359       {
43360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43361       };
43362     }
43363   }
43364
43365   jresult = (unsigned long)result;
43366   return jresult;
43367 }
43368
43369
43370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43371   void * jresult ;
43372   float arg1 ;
43373   Dali::TimePeriod *result = 0 ;
43374
43375   arg1 = (float)jarg1;
43376   {
43377     try {
43378       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43379     } catch (std::out_of_range& e) {
43380       {
43381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43382       };
43383     } catch (std::exception& e) {
43384       {
43385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43386       };
43387     } catch (Dali::DaliException e) {
43388       {
43389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43390       };
43391     } catch (...) {
43392       {
43393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43394       };
43395     }
43396   }
43397
43398   jresult = (void *)result;
43399   return jresult;
43400 }
43401
43402
43403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43404   void * jresult ;
43405   float arg1 ;
43406   float arg2 ;
43407   Dali::TimePeriod *result = 0 ;
43408
43409   arg1 = (float)jarg1;
43410   arg2 = (float)jarg2;
43411   {
43412     try {
43413       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43414     } catch (std::out_of_range& e) {
43415       {
43416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43417       };
43418     } catch (std::exception& e) {
43419       {
43420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43421       };
43422     } catch (Dali::DaliException e) {
43423       {
43424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43425       };
43426     } catch (...) {
43427       {
43428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43429       };
43430     }
43431   }
43432
43433   jresult = (void *)result;
43434   return jresult;
43435 }
43436
43437
43438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
43439   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43440
43441   arg1 = (Dali::TimePeriod *)jarg1;
43442   {
43443     try {
43444       delete arg1;
43445     } catch (std::out_of_range& e) {
43446       {
43447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43448       };
43449     } catch (std::exception& e) {
43450       {
43451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43452       };
43453     } catch (Dali::DaliException e) {
43454       {
43455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43456       };
43457     } catch (...) {
43458       {
43459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43460       };
43461     }
43462   }
43463
43464 }
43465
43466
43467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
43468   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43469   float arg2 ;
43470
43471   arg1 = (Dali::TimePeriod *)jarg1;
43472   arg2 = (float)jarg2;
43473   if (arg1) (arg1)->delaySeconds = arg2;
43474 }
43475
43476
43477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
43478   float jresult ;
43479   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43480   float result;
43481
43482   arg1 = (Dali::TimePeriod *)jarg1;
43483   result = (float) ((arg1)->delaySeconds);
43484   jresult = result;
43485   return jresult;
43486 }
43487
43488
43489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
43490   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43491   float arg2 ;
43492
43493   arg1 = (Dali::TimePeriod *)jarg1;
43494   arg2 = (float)jarg2;
43495   if (arg1) (arg1)->durationSeconds = arg2;
43496 }
43497
43498
43499 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
43500   float jresult ;
43501   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43502   float result;
43503
43504   arg1 = (Dali::TimePeriod *)jarg1;
43505   result = (float) ((arg1)->durationSeconds);
43506   jresult = result;
43507   return jresult;
43508 }
43509
43510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
43511   int jresult ;
43512   int result;
43513
43514   result = (int)Dali::LinearConstrainer::Property::VALUE;
43515   jresult = (int)result;
43516   return jresult;
43517 }
43518
43519
43520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
43521   int jresult ;
43522   int result;
43523
43524   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
43525   jresult = (int)result;
43526   return jresult;
43527 }
43528
43529
43530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
43531   void * jresult ;
43532   Dali::LinearConstrainer::Property *result = 0 ;
43533
43534   {
43535     try {
43536       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
43537     } catch (std::out_of_range& e) {
43538       {
43539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43540       };
43541     } catch (std::exception& e) {
43542       {
43543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43544       };
43545     } catch (Dali::DaliException e) {
43546       {
43547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43548       };
43549     } catch (...) {
43550       {
43551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43552       };
43553     }
43554   }
43555
43556   jresult = (void *)result;
43557   return jresult;
43558 }
43559
43560
43561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
43562   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
43563
43564   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
43565   {
43566     try {
43567       delete arg1;
43568     } catch (std::out_of_range& e) {
43569       {
43570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43571       };
43572     } catch (std::exception& e) {
43573       {
43574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43575       };
43576     } catch (Dali::DaliException e) {
43577       {
43578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43579       };
43580     } catch (...) {
43581       {
43582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43583       };
43584     }
43585   }
43586
43587 }
43588
43589
43590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
43591   void * jresult ;
43592   Dali::LinearConstrainer result;
43593
43594   {
43595     try {
43596       result = Dali::LinearConstrainer::New();
43597     } catch (std::out_of_range& e) {
43598       {
43599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43600       };
43601     } catch (std::exception& e) {
43602       {
43603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43604       };
43605     } catch (Dali::DaliException e) {
43606       {
43607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43608       };
43609     } catch (...) {
43610       {
43611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43612       };
43613     }
43614   }
43615
43616   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43617   return jresult;
43618 }
43619
43620
43621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
43622   void * jresult ;
43623   Dali::BaseHandle arg1 ;
43624   Dali::BaseHandle *argp1 ;
43625   Dali::LinearConstrainer result;
43626
43627   argp1 = (Dali::BaseHandle *)jarg1;
43628   if (!argp1) {
43629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43630     return 0;
43631   }
43632   arg1 = *argp1;
43633   {
43634     try {
43635       result = Dali::LinearConstrainer::DownCast(arg1);
43636     } catch (std::out_of_range& e) {
43637       {
43638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43639       };
43640     } catch (std::exception& e) {
43641       {
43642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43643       };
43644     } catch (Dali::DaliException e) {
43645       {
43646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43647       };
43648     } catch (...) {
43649       {
43650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43651       };
43652     }
43653   }
43654
43655   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43656   return jresult;
43657 }
43658
43659
43660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
43661   void * jresult ;
43662   Dali::LinearConstrainer *result = 0 ;
43663
43664   {
43665     try {
43666       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
43667     } catch (std::out_of_range& e) {
43668       {
43669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43670       };
43671     } catch (std::exception& e) {
43672       {
43673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43674       };
43675     } catch (Dali::DaliException e) {
43676       {
43677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43678       };
43679     } catch (...) {
43680       {
43681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43682       };
43683     }
43684   }
43685
43686   jresult = (void *)result;
43687   return jresult;
43688 }
43689
43690
43691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
43692   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43693
43694   arg1 = (Dali::LinearConstrainer *)jarg1;
43695   {
43696     try {
43697       delete arg1;
43698     } catch (std::out_of_range& e) {
43699       {
43700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43701       };
43702     } catch (std::exception& e) {
43703       {
43704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43705       };
43706     } catch (Dali::DaliException e) {
43707       {
43708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43709       };
43710     } catch (...) {
43711       {
43712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43713       };
43714     }
43715   }
43716
43717 }
43718
43719
43720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
43721   void * jresult ;
43722   Dali::LinearConstrainer *arg1 = 0 ;
43723   Dali::LinearConstrainer *result = 0 ;
43724
43725   arg1 = (Dali::LinearConstrainer *)jarg1;
43726   if (!arg1) {
43727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43728     return 0;
43729   }
43730   {
43731     try {
43732       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
43733     } catch (std::out_of_range& e) {
43734       {
43735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43736       };
43737     } catch (std::exception& e) {
43738       {
43739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43740       };
43741     } catch (Dali::DaliException e) {
43742       {
43743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43744       };
43745     } catch (...) {
43746       {
43747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43748       };
43749     }
43750   }
43751
43752   jresult = (void *)result;
43753   return jresult;
43754 }
43755
43756
43757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
43758   void * jresult ;
43759   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43760   Dali::LinearConstrainer *arg2 = 0 ;
43761   Dali::LinearConstrainer *result = 0 ;
43762
43763   arg1 = (Dali::LinearConstrainer *)jarg1;
43764   arg2 = (Dali::LinearConstrainer *)jarg2;
43765   if (!arg2) {
43766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43767     return 0;
43768   }
43769   {
43770     try {
43771       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
43772     } catch (std::out_of_range& e) {
43773       {
43774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43775       };
43776     } catch (std::exception& e) {
43777       {
43778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43779       };
43780     } catch (Dali::DaliException e) {
43781       {
43782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43783       };
43784     } catch (...) {
43785       {
43786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43787       };
43788     }
43789   }
43790
43791   jresult = (void *)result;
43792   return jresult;
43793 }
43794
43795
43796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
43797   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43798   SwigValueWrapper< Dali::Property > arg2 ;
43799   SwigValueWrapper< Dali::Property > arg3 ;
43800   Dali::Vector2 *arg4 = 0 ;
43801   Dali::Vector2 *arg5 = 0 ;
43802   Dali::Property *argp2 ;
43803   Dali::Property *argp3 ;
43804
43805   arg1 = (Dali::LinearConstrainer *)jarg1;
43806   argp2 = (Dali::Property *)jarg2;
43807   if (!argp2) {
43808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43809     return ;
43810   }
43811   arg2 = *argp2;
43812   argp3 = (Dali::Property *)jarg3;
43813   if (!argp3) {
43814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43815     return ;
43816   }
43817   arg3 = *argp3;
43818   arg4 = (Dali::Vector2 *)jarg4;
43819   if (!arg4) {
43820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43821     return ;
43822   }
43823   arg5 = (Dali::Vector2 *)jarg5;
43824   if (!arg5) {
43825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43826     return ;
43827   }
43828   {
43829     try {
43830       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
43831     } catch (std::out_of_range& e) {
43832       {
43833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43834       };
43835     } catch (std::exception& e) {
43836       {
43837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43838       };
43839     } catch (Dali::DaliException e) {
43840       {
43841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43842       };
43843     } catch (...) {
43844       {
43845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43846       };
43847     }
43848   }
43849
43850 }
43851
43852
43853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
43854   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43855   SwigValueWrapper< Dali::Property > arg2 ;
43856   SwigValueWrapper< Dali::Property > arg3 ;
43857   Dali::Vector2 *arg4 = 0 ;
43858   Dali::Property *argp2 ;
43859   Dali::Property *argp3 ;
43860
43861   arg1 = (Dali::LinearConstrainer *)jarg1;
43862   argp2 = (Dali::Property *)jarg2;
43863   if (!argp2) {
43864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43865     return ;
43866   }
43867   arg2 = *argp2;
43868   argp3 = (Dali::Property *)jarg3;
43869   if (!argp3) {
43870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43871     return ;
43872   }
43873   arg3 = *argp3;
43874   arg4 = (Dali::Vector2 *)jarg4;
43875   if (!arg4) {
43876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43877     return ;
43878   }
43879   {
43880     try {
43881       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
43882     } catch (std::out_of_range& e) {
43883       {
43884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43885       };
43886     } catch (std::exception& e) {
43887       {
43888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43889       };
43890     } catch (Dali::DaliException e) {
43891       {
43892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43893       };
43894     } catch (...) {
43895       {
43896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43897       };
43898     }
43899   }
43900
43901 }
43902
43903
43904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
43905   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43906   Dali::Handle *arg2 = 0 ;
43907
43908   arg1 = (Dali::LinearConstrainer *)jarg1;
43909   arg2 = (Dali::Handle *)jarg2;
43910   if (!arg2) {
43911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
43912     return ;
43913   }
43914   {
43915     try {
43916       (arg1)->Remove(*arg2);
43917     } catch (std::out_of_range& e) {
43918       {
43919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43920       };
43921     } catch (std::exception& e) {
43922       {
43923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43924       };
43925     } catch (Dali::DaliException e) {
43926       {
43927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43928       };
43929     } catch (...) {
43930       {
43931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43932       };
43933     }
43934   }
43935
43936 }
43937
43938
43939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
43940   int jresult ;
43941   int result;
43942
43943   result = (int)Dali::PathConstrainer::Property::FORWARD;
43944   jresult = (int)result;
43945   return jresult;
43946 }
43947
43948
43949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
43950   int jresult ;
43951   int result;
43952
43953   result = (int)Dali::PathConstrainer::Property::POINTS;
43954   jresult = (int)result;
43955   return jresult;
43956 }
43957
43958
43959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
43960   int jresult ;
43961   int result;
43962
43963   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
43964   jresult = (int)result;
43965   return jresult;
43966 }
43967
43968
43969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
43970   void * jresult ;
43971   Dali::PathConstrainer::Property *result = 0 ;
43972
43973   {
43974     try {
43975       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
43976     } catch (std::out_of_range& e) {
43977       {
43978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43979       };
43980     } catch (std::exception& e) {
43981       {
43982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43983       };
43984     } catch (Dali::DaliException e) {
43985       {
43986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43987       };
43988     } catch (...) {
43989       {
43990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43991       };
43992     }
43993   }
43994
43995   jresult = (void *)result;
43996   return jresult;
43997 }
43998
43999
44000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44001   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44002
44003   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44004   {
44005     try {
44006       delete arg1;
44007     } catch (std::out_of_range& e) {
44008       {
44009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44010       };
44011     } catch (std::exception& e) {
44012       {
44013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44014       };
44015     } catch (Dali::DaliException e) {
44016       {
44017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44018       };
44019     } catch (...) {
44020       {
44021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44022       };
44023     }
44024   }
44025
44026 }
44027
44028
44029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44030   void * jresult ;
44031   Dali::PathConstrainer result;
44032
44033   {
44034     try {
44035       result = Dali::PathConstrainer::New();
44036     } catch (std::out_of_range& e) {
44037       {
44038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44039       };
44040     } catch (std::exception& e) {
44041       {
44042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44043       };
44044     } catch (Dali::DaliException e) {
44045       {
44046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44047       };
44048     } catch (...) {
44049       {
44050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44051       };
44052     }
44053   }
44054
44055   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44056   return jresult;
44057 }
44058
44059
44060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44061   void * jresult ;
44062   Dali::BaseHandle arg1 ;
44063   Dali::BaseHandle *argp1 ;
44064   Dali::PathConstrainer result;
44065
44066   argp1 = (Dali::BaseHandle *)jarg1;
44067   if (!argp1) {
44068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44069     return 0;
44070   }
44071   arg1 = *argp1;
44072   {
44073     try {
44074       result = Dali::PathConstrainer::DownCast(arg1);
44075     } catch (std::out_of_range& e) {
44076       {
44077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44078       };
44079     } catch (std::exception& e) {
44080       {
44081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44082       };
44083     } catch (Dali::DaliException e) {
44084       {
44085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44086       };
44087     } catch (...) {
44088       {
44089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44090       };
44091     }
44092   }
44093
44094   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44095   return jresult;
44096 }
44097
44098
44099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44100   void * jresult ;
44101   Dali::PathConstrainer *result = 0 ;
44102
44103   {
44104     try {
44105       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44106     } catch (std::out_of_range& e) {
44107       {
44108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44109       };
44110     } catch (std::exception& e) {
44111       {
44112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44113       };
44114     } catch (Dali::DaliException e) {
44115       {
44116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44117       };
44118     } catch (...) {
44119       {
44120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44121       };
44122     }
44123   }
44124
44125   jresult = (void *)result;
44126   return jresult;
44127 }
44128
44129
44130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44131   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44132
44133   arg1 = (Dali::PathConstrainer *)jarg1;
44134   {
44135     try {
44136       delete arg1;
44137     } catch (std::out_of_range& e) {
44138       {
44139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44140       };
44141     } catch (std::exception& e) {
44142       {
44143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44144       };
44145     } catch (Dali::DaliException e) {
44146       {
44147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44148       };
44149     } catch (...) {
44150       {
44151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44152       };
44153     }
44154   }
44155
44156 }
44157
44158
44159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44160   void * jresult ;
44161   Dali::PathConstrainer *arg1 = 0 ;
44162   Dali::PathConstrainer *result = 0 ;
44163
44164   arg1 = (Dali::PathConstrainer *)jarg1;
44165   if (!arg1) {
44166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44167     return 0;
44168   }
44169   {
44170     try {
44171       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44172     } catch (std::out_of_range& e) {
44173       {
44174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44175       };
44176     } catch (std::exception& e) {
44177       {
44178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44179       };
44180     } catch (Dali::DaliException e) {
44181       {
44182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44183       };
44184     } catch (...) {
44185       {
44186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44187       };
44188     }
44189   }
44190
44191   jresult = (void *)result;
44192   return jresult;
44193 }
44194
44195
44196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44197   void * jresult ;
44198   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44199   Dali::PathConstrainer *arg2 = 0 ;
44200   Dali::PathConstrainer *result = 0 ;
44201
44202   arg1 = (Dali::PathConstrainer *)jarg1;
44203   arg2 = (Dali::PathConstrainer *)jarg2;
44204   if (!arg2) {
44205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44206     return 0;
44207   }
44208   {
44209     try {
44210       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44211     } catch (std::out_of_range& e) {
44212       {
44213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44214       };
44215     } catch (std::exception& e) {
44216       {
44217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44218       };
44219     } catch (Dali::DaliException e) {
44220       {
44221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44222       };
44223     } catch (...) {
44224       {
44225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44226       };
44227     }
44228   }
44229
44230   jresult = (void *)result;
44231   return jresult;
44232 }
44233
44234
44235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44236   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44237   SwigValueWrapper< Dali::Property > arg2 ;
44238   SwigValueWrapper< Dali::Property > arg3 ;
44239   Dali::Vector2 *arg4 = 0 ;
44240   Dali::Vector2 *arg5 = 0 ;
44241   Dali::Property *argp2 ;
44242   Dali::Property *argp3 ;
44243
44244   arg1 = (Dali::PathConstrainer *)jarg1;
44245   argp2 = (Dali::Property *)jarg2;
44246   if (!argp2) {
44247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44248     return ;
44249   }
44250   arg2 = *argp2;
44251   argp3 = (Dali::Property *)jarg3;
44252   if (!argp3) {
44253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44254     return ;
44255   }
44256   arg3 = *argp3;
44257   arg4 = (Dali::Vector2 *)jarg4;
44258   if (!arg4) {
44259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44260     return ;
44261   }
44262   arg5 = (Dali::Vector2 *)jarg5;
44263   if (!arg5) {
44264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44265     return ;
44266   }
44267   {
44268     try {
44269       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44270     } catch (std::out_of_range& e) {
44271       {
44272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44273       };
44274     } catch (std::exception& e) {
44275       {
44276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44277       };
44278     } catch (Dali::DaliException e) {
44279       {
44280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44281       };
44282     } catch (...) {
44283       {
44284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44285       };
44286     }
44287   }
44288
44289 }
44290
44291
44292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44293   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44294   SwigValueWrapper< Dali::Property > arg2 ;
44295   SwigValueWrapper< Dali::Property > arg3 ;
44296   Dali::Vector2 *arg4 = 0 ;
44297   Dali::Property *argp2 ;
44298   Dali::Property *argp3 ;
44299
44300   arg1 = (Dali::PathConstrainer *)jarg1;
44301   argp2 = (Dali::Property *)jarg2;
44302   if (!argp2) {
44303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44304     return ;
44305   }
44306   arg2 = *argp2;
44307   argp3 = (Dali::Property *)jarg3;
44308   if (!argp3) {
44309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44310     return ;
44311   }
44312   arg3 = *argp3;
44313   arg4 = (Dali::Vector2 *)jarg4;
44314   if (!arg4) {
44315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44316     return ;
44317   }
44318   {
44319     try {
44320       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44321     } catch (std::out_of_range& e) {
44322       {
44323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44324       };
44325     } catch (std::exception& e) {
44326       {
44327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44328       };
44329     } catch (Dali::DaliException e) {
44330       {
44331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44332       };
44333     } catch (...) {
44334       {
44335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44336       };
44337     }
44338   }
44339
44340 }
44341
44342
44343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44344   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44345   Dali::Handle *arg2 = 0 ;
44346
44347   arg1 = (Dali::PathConstrainer *)jarg1;
44348   arg2 = (Dali::Handle *)jarg2;
44349   if (!arg2) {
44350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44351     return ;
44352   }
44353   {
44354     try {
44355       (arg1)->Remove(*arg2);
44356     } catch (std::out_of_range& e) {
44357       {
44358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44359       };
44360     } catch (std::exception& e) {
44361       {
44362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44363       };
44364     } catch (Dali::DaliException e) {
44365       {
44366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44367       };
44368     } catch (...) {
44369       {
44370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44371       };
44372     }
44373   }
44374
44375 }
44376
44377
44378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44379   int jresult ;
44380   Dali::FittingMode::Type result;
44381
44382   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44383   jresult = (int)result;
44384   return jresult;
44385 }
44386
44387
44388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44389   int jresult ;
44390   Dali::SamplingMode::Type result;
44391
44392   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44393   jresult = (int)result;
44394   return jresult;
44395 }
44396
44397
44398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
44399   unsigned int jresult ;
44400   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44401   bool result;
44402
44403   arg1 = (Dali::NativeImageInterface *)jarg1;
44404   {
44405     try {
44406       result = (bool)(arg1)->CreateResource();
44407     } catch (std::out_of_range& e) {
44408       {
44409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44410       };
44411     } catch (std::exception& e) {
44412       {
44413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44414       };
44415     } catch (Dali::DaliException e) {
44416       {
44417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44418       };
44419     } catch (...) {
44420       {
44421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44422       };
44423     }
44424   }
44425
44426   jresult = result;
44427   return jresult;
44428 }
44429
44430
44431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
44432   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44433
44434   arg1 = (Dali::NativeImageInterface *)jarg1;
44435   {
44436     try {
44437       (arg1)->DestroyResource();
44438     } catch (std::out_of_range& e) {
44439       {
44440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44441       };
44442     } catch (std::exception& e) {
44443       {
44444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44445       };
44446     } catch (Dali::DaliException e) {
44447       {
44448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44449       };
44450     } catch (...) {
44451       {
44452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44453       };
44454     }
44455   }
44456
44457 }
44458
44459
44460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
44461   unsigned int jresult ;
44462   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44463   unsigned int result;
44464
44465   arg1 = (Dali::NativeImageInterface *)jarg1;
44466   {
44467     try {
44468       result = (unsigned int)(arg1)->TargetTexture();
44469     } catch (std::out_of_range& e) {
44470       {
44471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44472       };
44473     } catch (std::exception& e) {
44474       {
44475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44476       };
44477     } catch (Dali::DaliException e) {
44478       {
44479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44480       };
44481     } catch (...) {
44482       {
44483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44484       };
44485     }
44486   }
44487
44488   jresult = result;
44489   return jresult;
44490 }
44491
44492
44493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
44494   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44495
44496   arg1 = (Dali::NativeImageInterface *)jarg1;
44497   {
44498     try {
44499       (arg1)->PrepareTexture();
44500     } catch (std::out_of_range& e) {
44501       {
44502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44503       };
44504     } catch (std::exception& e) {
44505       {
44506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44507       };
44508     } catch (Dali::DaliException e) {
44509       {
44510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44511       };
44512     } catch (...) {
44513       {
44514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44515       };
44516     }
44517   }
44518
44519 }
44520
44521
44522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
44523   unsigned int jresult ;
44524   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44525   unsigned int result;
44526
44527   arg1 = (Dali::NativeImageInterface *)jarg1;
44528   {
44529     try {
44530       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
44531     } catch (std::out_of_range& e) {
44532       {
44533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44534       };
44535     } catch (std::exception& e) {
44536       {
44537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44538       };
44539     } catch (Dali::DaliException e) {
44540       {
44541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44542       };
44543     } catch (...) {
44544       {
44545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44546       };
44547     }
44548   }
44549
44550   jresult = result;
44551   return jresult;
44552 }
44553
44554
44555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
44556   unsigned int jresult ;
44557   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44558   unsigned int result;
44559
44560   arg1 = (Dali::NativeImageInterface *)jarg1;
44561   {
44562     try {
44563       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
44564     } catch (std::out_of_range& e) {
44565       {
44566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44567       };
44568     } catch (std::exception& e) {
44569       {
44570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44571       };
44572     } catch (Dali::DaliException e) {
44573       {
44574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44575       };
44576     } catch (...) {
44577       {
44578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44579       };
44580     }
44581   }
44582
44583   jresult = result;
44584   return jresult;
44585 }
44586
44587
44588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
44589   unsigned int jresult ;
44590   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44591   bool result;
44592
44593   arg1 = (Dali::NativeImageInterface *)jarg1;
44594   {
44595     try {
44596       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
44597     } catch (std::out_of_range& e) {
44598       {
44599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44600       };
44601     } catch (std::exception& e) {
44602       {
44603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44604       };
44605     } catch (Dali::DaliException e) {
44606       {
44607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44608       };
44609     } catch (...) {
44610       {
44611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44612       };
44613     }
44614   }
44615
44616   jresult = result;
44617   return jresult;
44618 }
44619
44620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
44621   int jresult ;
44622   int result;
44623
44624   result = (int)Dali::CameraActor::Property::TYPE;
44625   jresult = (int)result;
44626   return jresult;
44627 }
44628
44629
44630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
44631   int jresult ;
44632   int result;
44633
44634   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
44635   jresult = (int)result;
44636   return jresult;
44637 }
44638
44639
44640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
44641   int jresult ;
44642   int result;
44643
44644   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
44645   jresult = (int)result;
44646   return jresult;
44647 }
44648
44649
44650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
44651   int jresult ;
44652   int result;
44653
44654   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
44655   jresult = (int)result;
44656   return jresult;
44657 }
44658
44659
44660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
44661   int jresult ;
44662   int result;
44663
44664   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
44665   jresult = (int)result;
44666   return jresult;
44667 }
44668
44669
44670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
44671   int jresult ;
44672   int result;
44673
44674   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
44675   jresult = (int)result;
44676   return jresult;
44677 }
44678
44679
44680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
44681   int jresult ;
44682   int result;
44683
44684   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
44685   jresult = (int)result;
44686   return jresult;
44687 }
44688
44689
44690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
44691   int jresult ;
44692   int result;
44693
44694   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
44695   jresult = (int)result;
44696   return jresult;
44697 }
44698
44699
44700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
44701   int jresult ;
44702   int result;
44703
44704   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
44705   jresult = (int)result;
44706   return jresult;
44707 }
44708
44709
44710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
44711   int jresult ;
44712   int result;
44713
44714   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
44715   jresult = (int)result;
44716   return jresult;
44717 }
44718
44719
44720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
44721   int jresult ;
44722   int result;
44723
44724   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
44725   jresult = (int)result;
44726   return jresult;
44727 }
44728
44729
44730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
44731   int jresult ;
44732   int result;
44733
44734   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
44735   jresult = (int)result;
44736   return jresult;
44737 }
44738
44739
44740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
44741   int jresult ;
44742   int result;
44743
44744   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
44745   jresult = (int)result;
44746   return jresult;
44747 }
44748
44749
44750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
44751   int jresult ;
44752   int result;
44753
44754   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
44755   jresult = (int)result;
44756   return jresult;
44757 }
44758
44759
44760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
44761   void * jresult ;
44762   Dali::CameraActor::Property *result = 0 ;
44763
44764   {
44765     try {
44766       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
44767     } catch (std::out_of_range& e) {
44768       {
44769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44770       };
44771     } catch (std::exception& e) {
44772       {
44773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44774       };
44775     } catch (Dali::DaliException e) {
44776       {
44777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44778       };
44779     } catch (...) {
44780       {
44781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44782       };
44783     }
44784   }
44785
44786   jresult = (void *)result;
44787   return jresult;
44788 }
44789
44790
44791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
44792   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
44793
44794   arg1 = (Dali::CameraActor::Property *)jarg1;
44795   {
44796     try {
44797       delete arg1;
44798     } catch (std::out_of_range& e) {
44799       {
44800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44801       };
44802     } catch (std::exception& e) {
44803       {
44804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44805       };
44806     } catch (Dali::DaliException e) {
44807       {
44808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44809       };
44810     } catch (...) {
44811       {
44812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44813       };
44814     }
44815   }
44816
44817 }
44818
44819
44820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
44821   void * jresult ;
44822   Dali::CameraActor *result = 0 ;
44823
44824   {
44825     try {
44826       result = (Dali::CameraActor *)new Dali::CameraActor();
44827     } catch (std::out_of_range& e) {
44828       {
44829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44830       };
44831     } catch (std::exception& e) {
44832       {
44833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44834       };
44835     } catch (Dali::DaliException e) {
44836       {
44837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44838       };
44839     } catch (...) {
44840       {
44841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44842       };
44843     }
44844   }
44845
44846   jresult = (void *)result;
44847   return jresult;
44848 }
44849
44850
44851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
44852   void * jresult ;
44853   Dali::CameraActor result;
44854
44855   {
44856     try {
44857       result = Dali::CameraActor::New();
44858     } catch (std::out_of_range& e) {
44859       {
44860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44861       };
44862     } catch (std::exception& e) {
44863       {
44864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44865       };
44866     } catch (Dali::DaliException e) {
44867       {
44868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44869       };
44870     } catch (...) {
44871       {
44872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44873       };
44874     }
44875   }
44876
44877   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44878   return jresult;
44879 }
44880
44881
44882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
44883   void * jresult ;
44884   Dali::Size *arg1 = 0 ;
44885   Dali::CameraActor result;
44886
44887   arg1 = (Dali::Size *)jarg1;
44888   if (!arg1) {
44889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44890     return 0;
44891   }
44892   {
44893     try {
44894       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
44895     } catch (std::out_of_range& e) {
44896       {
44897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44898       };
44899     } catch (std::exception& e) {
44900       {
44901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44902       };
44903     } catch (Dali::DaliException e) {
44904       {
44905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44906       };
44907     } catch (...) {
44908       {
44909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44910       };
44911     }
44912   }
44913
44914   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44915   return jresult;
44916 }
44917
44918
44919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
44920   void * jresult ;
44921   Dali::BaseHandle arg1 ;
44922   Dali::BaseHandle *argp1 ;
44923   Dali::CameraActor result;
44924
44925   argp1 = (Dali::BaseHandle *)jarg1;
44926   if (!argp1) {
44927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44928     return 0;
44929   }
44930   arg1 = *argp1;
44931   {
44932     try {
44933       result = Dali::CameraActor::DownCast(arg1);
44934     } catch (std::out_of_range& e) {
44935       {
44936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44937       };
44938     } catch (std::exception& e) {
44939       {
44940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44941       };
44942     } catch (Dali::DaliException e) {
44943       {
44944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44945       };
44946     } catch (...) {
44947       {
44948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44949       };
44950     }
44951   }
44952
44953   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44954   return jresult;
44955 }
44956
44957
44958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
44959   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44960
44961   arg1 = (Dali::CameraActor *)jarg1;
44962   {
44963     try {
44964       delete arg1;
44965     } catch (std::out_of_range& e) {
44966       {
44967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44968       };
44969     } catch (std::exception& e) {
44970       {
44971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44972       };
44973     } catch (Dali::DaliException e) {
44974       {
44975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44976       };
44977     } catch (...) {
44978       {
44979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44980       };
44981     }
44982   }
44983
44984 }
44985
44986
44987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
44988   void * jresult ;
44989   Dali::CameraActor *arg1 = 0 ;
44990   Dali::CameraActor *result = 0 ;
44991
44992   arg1 = (Dali::CameraActor *)jarg1;
44993   if (!arg1) {
44994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44995     return 0;
44996   }
44997   {
44998     try {
44999       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
45000     } catch (std::out_of_range& e) {
45001       {
45002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45003       };
45004     } catch (std::exception& e) {
45005       {
45006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45007       };
45008     } catch (Dali::DaliException e) {
45009       {
45010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45011       };
45012     } catch (...) {
45013       {
45014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45015       };
45016     }
45017   }
45018
45019   jresult = (void *)result;
45020   return jresult;
45021 }
45022
45023
45024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
45025   void * jresult ;
45026   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45027   Dali::CameraActor *arg2 = 0 ;
45028   Dali::CameraActor *result = 0 ;
45029
45030   arg1 = (Dali::CameraActor *)jarg1;
45031   arg2 = (Dali::CameraActor *)jarg2;
45032   if (!arg2) {
45033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
45034     return 0;
45035   }
45036   {
45037     try {
45038       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
45039     } catch (std::out_of_range& e) {
45040       {
45041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45042       };
45043     } catch (std::exception& e) {
45044       {
45045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45046       };
45047     } catch (Dali::DaliException e) {
45048       {
45049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45050       };
45051     } catch (...) {
45052       {
45053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45054       };
45055     }
45056   }
45057
45058   jresult = (void *)result;
45059   return jresult;
45060 }
45061
45062
45063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
45064   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45065   Dali::Camera::Type arg2 ;
45066
45067   arg1 = (Dali::CameraActor *)jarg1;
45068   arg2 = (Dali::Camera::Type)jarg2;
45069   {
45070     try {
45071       (arg1)->SetType(arg2);
45072     } catch (std::out_of_range& e) {
45073       {
45074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45075       };
45076     } catch (std::exception& e) {
45077       {
45078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45079       };
45080     } catch (Dali::DaliException e) {
45081       {
45082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45083       };
45084     } catch (...) {
45085       {
45086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45087       };
45088     }
45089   }
45090
45091 }
45092
45093
45094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
45095   int jresult ;
45096   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45097   Dali::Camera::Type result;
45098
45099   arg1 = (Dali::CameraActor *)jarg1;
45100   {
45101     try {
45102       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
45103     } catch (std::out_of_range& e) {
45104       {
45105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45106       };
45107     } catch (std::exception& e) {
45108       {
45109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45110       };
45111     } catch (Dali::DaliException e) {
45112       {
45113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45114       };
45115     } catch (...) {
45116       {
45117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45118       };
45119     }
45120   }
45121
45122   jresult = (int)result;
45123   return jresult;
45124 }
45125
45126
45127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
45128   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45129   Dali::Camera::ProjectionMode arg2 ;
45130
45131   arg1 = (Dali::CameraActor *)jarg1;
45132   arg2 = (Dali::Camera::ProjectionMode)jarg2;
45133   {
45134     try {
45135       (arg1)->SetProjectionMode(arg2);
45136     } catch (std::out_of_range& e) {
45137       {
45138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45139       };
45140     } catch (std::exception& e) {
45141       {
45142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45143       };
45144     } catch (Dali::DaliException e) {
45145       {
45146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45147       };
45148     } catch (...) {
45149       {
45150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45151       };
45152     }
45153   }
45154
45155 }
45156
45157
45158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
45159   int jresult ;
45160   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45161   Dali::Camera::ProjectionMode result;
45162
45163   arg1 = (Dali::CameraActor *)jarg1;
45164   {
45165     try {
45166       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
45167     } catch (std::out_of_range& e) {
45168       {
45169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45170       };
45171     } catch (std::exception& e) {
45172       {
45173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45174       };
45175     } catch (Dali::DaliException e) {
45176       {
45177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45178       };
45179     } catch (...) {
45180       {
45181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45182       };
45183     }
45184   }
45185
45186   jresult = (int)result;
45187   return jresult;
45188 }
45189
45190
45191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
45192   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45193   float arg2 ;
45194
45195   arg1 = (Dali::CameraActor *)jarg1;
45196   arg2 = (float)jarg2;
45197   {
45198     try {
45199       (arg1)->SetFieldOfView(arg2);
45200     } catch (std::out_of_range& e) {
45201       {
45202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45203       };
45204     } catch (std::exception& e) {
45205       {
45206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45207       };
45208     } catch (Dali::DaliException e) {
45209       {
45210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45211       };
45212     } catch (...) {
45213       {
45214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45215       };
45216     }
45217   }
45218
45219 }
45220
45221
45222 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
45223   float jresult ;
45224   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45225   float result;
45226
45227   arg1 = (Dali::CameraActor *)jarg1;
45228   {
45229     try {
45230       result = (float)(arg1)->GetFieldOfView();
45231     } catch (std::out_of_range& e) {
45232       {
45233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45234       };
45235     } catch (std::exception& e) {
45236       {
45237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45238       };
45239     } catch (Dali::DaliException e) {
45240       {
45241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45242       };
45243     } catch (...) {
45244       {
45245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45246       };
45247     }
45248   }
45249
45250   jresult = result;
45251   return jresult;
45252 }
45253
45254
45255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
45256   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45257   float arg2 ;
45258
45259   arg1 = (Dali::CameraActor *)jarg1;
45260   arg2 = (float)jarg2;
45261   {
45262     try {
45263       (arg1)->SetAspectRatio(arg2);
45264     } catch (std::out_of_range& e) {
45265       {
45266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45267       };
45268     } catch (std::exception& e) {
45269       {
45270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45271       };
45272     } catch (Dali::DaliException e) {
45273       {
45274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45275       };
45276     } catch (...) {
45277       {
45278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45279       };
45280     }
45281   }
45282
45283 }
45284
45285
45286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
45287   float jresult ;
45288   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45289   float result;
45290
45291   arg1 = (Dali::CameraActor *)jarg1;
45292   {
45293     try {
45294       result = (float)(arg1)->GetAspectRatio();
45295     } catch (std::out_of_range& e) {
45296       {
45297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45298       };
45299     } catch (std::exception& e) {
45300       {
45301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45302       };
45303     } catch (Dali::DaliException e) {
45304       {
45305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45306       };
45307     } catch (...) {
45308       {
45309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45310       };
45311     }
45312   }
45313
45314   jresult = result;
45315   return jresult;
45316 }
45317
45318
45319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
45320   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45321   float arg2 ;
45322
45323   arg1 = (Dali::CameraActor *)jarg1;
45324   arg2 = (float)jarg2;
45325   {
45326     try {
45327       (arg1)->SetNearClippingPlane(arg2);
45328     } catch (std::out_of_range& e) {
45329       {
45330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45331       };
45332     } catch (std::exception& e) {
45333       {
45334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45335       };
45336     } catch (Dali::DaliException e) {
45337       {
45338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45339       };
45340     } catch (...) {
45341       {
45342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45343       };
45344     }
45345   }
45346
45347 }
45348
45349
45350 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
45351   float jresult ;
45352   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45353   float result;
45354
45355   arg1 = (Dali::CameraActor *)jarg1;
45356   {
45357     try {
45358       result = (float)(arg1)->GetNearClippingPlane();
45359     } catch (std::out_of_range& e) {
45360       {
45361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45362       };
45363     } catch (std::exception& e) {
45364       {
45365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45366       };
45367     } catch (Dali::DaliException e) {
45368       {
45369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45370       };
45371     } catch (...) {
45372       {
45373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45374       };
45375     }
45376   }
45377
45378   jresult = result;
45379   return jresult;
45380 }
45381
45382
45383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
45384   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45385   float arg2 ;
45386
45387   arg1 = (Dali::CameraActor *)jarg1;
45388   arg2 = (float)jarg2;
45389   {
45390     try {
45391       (arg1)->SetFarClippingPlane(arg2);
45392     } catch (std::out_of_range& e) {
45393       {
45394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45395       };
45396     } catch (std::exception& e) {
45397       {
45398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45399       };
45400     } catch (Dali::DaliException e) {
45401       {
45402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45403       };
45404     } catch (...) {
45405       {
45406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45407       };
45408     }
45409   }
45410
45411 }
45412
45413
45414 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
45415   float jresult ;
45416   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45417   float result;
45418
45419   arg1 = (Dali::CameraActor *)jarg1;
45420   {
45421     try {
45422       result = (float)(arg1)->GetFarClippingPlane();
45423     } catch (std::out_of_range& e) {
45424       {
45425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45426       };
45427     } catch (std::exception& e) {
45428       {
45429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45430       };
45431     } catch (Dali::DaliException e) {
45432       {
45433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45434       };
45435     } catch (...) {
45436       {
45437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45438       };
45439     }
45440   }
45441
45442   jresult = result;
45443   return jresult;
45444 }
45445
45446
45447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
45448   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45449   Dali::Vector3 *arg2 = 0 ;
45450
45451   arg1 = (Dali::CameraActor *)jarg1;
45452   arg2 = (Dali::Vector3 *)jarg2;
45453   if (!arg2) {
45454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
45455     return ;
45456   }
45457   {
45458     try {
45459       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
45460     } catch (std::out_of_range& e) {
45461       {
45462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45463       };
45464     } catch (std::exception& e) {
45465       {
45466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45467       };
45468     } catch (Dali::DaliException e) {
45469       {
45470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45471       };
45472     } catch (...) {
45473       {
45474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45475       };
45476     }
45477   }
45478
45479 }
45480
45481
45482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
45483   void * jresult ;
45484   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45485   Dali::Vector3 result;
45486
45487   arg1 = (Dali::CameraActor *)jarg1;
45488   {
45489     try {
45490       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
45491     } catch (std::out_of_range& e) {
45492       {
45493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45494       };
45495     } catch (std::exception& e) {
45496       {
45497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45498       };
45499     } catch (Dali::DaliException e) {
45500       {
45501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45502       };
45503     } catch (...) {
45504       {
45505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45506       };
45507     }
45508   }
45509
45510   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
45511   return jresult;
45512 }
45513
45514
45515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
45516   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45517   bool arg2 ;
45518
45519   arg1 = (Dali::CameraActor *)jarg1;
45520   arg2 = jarg2 ? true : false;
45521   {
45522     try {
45523       (arg1)->SetInvertYAxis(arg2);
45524     } catch (std::out_of_range& e) {
45525       {
45526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45527       };
45528     } catch (std::exception& e) {
45529       {
45530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45531       };
45532     } catch (Dali::DaliException e) {
45533       {
45534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45535       };
45536     } catch (...) {
45537       {
45538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45539       };
45540     }
45541   }
45542
45543 }
45544
45545
45546 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
45547   unsigned int jresult ;
45548   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45549   bool result;
45550
45551   arg1 = (Dali::CameraActor *)jarg1;
45552   {
45553     try {
45554       result = (bool)(arg1)->GetInvertYAxis();
45555     } catch (std::out_of_range& e) {
45556       {
45557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45558       };
45559     } catch (std::exception& e) {
45560       {
45561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45562       };
45563     } catch (Dali::DaliException e) {
45564       {
45565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45566       };
45567     } catch (...) {
45568       {
45569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45570       };
45571     }
45572   }
45573
45574   jresult = result;
45575   return jresult;
45576 }
45577
45578
45579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
45580   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45581   Dali::Size *arg2 = 0 ;
45582
45583   arg1 = (Dali::CameraActor *)jarg1;
45584   arg2 = (Dali::Size *)jarg2;
45585   if (!arg2) {
45586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45587     return ;
45588   }
45589   {
45590     try {
45591       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
45592     } catch (std::out_of_range& e) {
45593       {
45594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45595       };
45596     } catch (std::exception& e) {
45597       {
45598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45599       };
45600     } catch (Dali::DaliException e) {
45601       {
45602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45603       };
45604     } catch (...) {
45605       {
45606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45607       };
45608     }
45609   }
45610
45611 }
45612
45613
45614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
45615   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45616   Dali::Size *arg2 = 0 ;
45617
45618   arg1 = (Dali::CameraActor *)jarg1;
45619   arg2 = (Dali::Size *)jarg2;
45620   if (!arg2) {
45621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45622     return ;
45623   }
45624   {
45625     try {
45626       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
45627     } catch (std::out_of_range& e) {
45628       {
45629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45630       };
45631     } catch (std::exception& e) {
45632       {
45633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45634       };
45635     } catch (Dali::DaliException e) {
45636       {
45637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45638       };
45639     } catch (...) {
45640       {
45641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45642       };
45643     }
45644   }
45645
45646 }
45647
45648
45649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
45650   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45651   float arg2 ;
45652   float arg3 ;
45653   float arg4 ;
45654   float arg5 ;
45655   float arg6 ;
45656   float arg7 ;
45657
45658   arg1 = (Dali::CameraActor *)jarg1;
45659   arg2 = (float)jarg2;
45660   arg3 = (float)jarg3;
45661   arg4 = (float)jarg4;
45662   arg5 = (float)jarg5;
45663   arg6 = (float)jarg6;
45664   arg7 = (float)jarg7;
45665   {
45666     try {
45667       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
45668     } catch (std::out_of_range& e) {
45669       {
45670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45671       };
45672     } catch (std::exception& e) {
45673       {
45674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45675       };
45676     } catch (Dali::DaliException e) {
45677       {
45678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45679       };
45680     } catch (...) {
45681       {
45682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45683       };
45684     }
45685   }
45686
45687 }
45688
45689
45690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
45691   void * jresult ;
45692   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45693
45694   {
45695     try {
45696       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
45697     } catch (std::out_of_range& e) {
45698       {
45699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45700       };
45701     } catch (std::exception& e) {
45702       {
45703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45704       };
45705     } catch (Dali::DaliException e) {
45706       {
45707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45708       };
45709     } catch (...) {
45710       {
45711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45712       };
45713     }
45714   }
45715
45716   jresult = (void *)result;
45717   return jresult;
45718 }
45719
45720
45721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
45722   void * jresult ;
45723   std::string arg1 ;
45724   Dali::Property::Value arg2 ;
45725   Dali::Property::Value *argp2 ;
45726   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45727
45728   if (!jarg1) {
45729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45730     return 0;
45731   }
45732   (&arg1)->assign(jarg1);
45733   argp2 = (Dali::Property::Value *)jarg2;
45734   if (!argp2) {
45735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
45736     return 0;
45737   }
45738   arg2 = *argp2;
45739   {
45740     try {
45741       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
45742     } catch (std::out_of_range& e) {
45743       {
45744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45745       };
45746     } catch (std::exception& e) {
45747       {
45748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45749       };
45750     } catch (Dali::DaliException e) {
45751       {
45752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45753       };
45754     } catch (...) {
45755       {
45756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45757       };
45758     }
45759   }
45760
45761   jresult = (void *)result;
45762   return jresult;
45763 }
45764
45765
45766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
45767   void * jresult ;
45768   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
45769   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45770
45771   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45772   if (!arg1) {
45773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
45774     return 0;
45775   }
45776   {
45777     try {
45778       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);
45779     } catch (std::out_of_range& e) {
45780       {
45781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45782       };
45783     } catch (std::exception& e) {
45784       {
45785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45786       };
45787     } catch (Dali::DaliException e) {
45788       {
45789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45790       };
45791     } catch (...) {
45792       {
45793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45794       };
45795     }
45796   }
45797
45798   jresult = (void *)result;
45799   return jresult;
45800 }
45801
45802
45803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
45804   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45805   std::string *arg2 = 0 ;
45806
45807   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45808   if (!jarg2) {
45809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45810     return ;
45811   }
45812   std::string arg2_str(jarg2);
45813   arg2 = &arg2_str;
45814   if (arg1) (arg1)->first = *arg2;
45815
45816   //argout typemap for const std::string&
45817
45818 }
45819
45820
45821 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
45822   char * jresult ;
45823   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45824   std::string *result = 0 ;
45825
45826   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45827   result = (std::string *) & ((arg1)->first);
45828   jresult = SWIG_csharp_string_callback(result->c_str());
45829   return jresult;
45830 }
45831
45832
45833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
45834   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45835   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
45836
45837   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45838   arg2 = (Dali::Property::Value *)jarg2;
45839   if (arg1) (arg1)->second = *arg2;
45840 }
45841
45842
45843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
45844   void * jresult ;
45845   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45846   Dali::Property::Value *result = 0 ;
45847
45848   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45849   result = (Dali::Property::Value *)& ((arg1)->second);
45850   jresult = (void *)result;
45851   return jresult;
45852 }
45853
45854
45855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
45856   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45857
45858   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45859   {
45860     try {
45861       delete arg1;
45862     } catch (std::out_of_range& e) {
45863       {
45864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45865       };
45866     } catch (std::exception& e) {
45867       {
45868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45869       };
45870     } catch (Dali::DaliException e) {
45871       {
45872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45873       };
45874     } catch (...) {
45875       {
45876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45877       };
45878     }
45879   }
45880
45881 }
45882
45883
45884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
45885   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45886
45887   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45888   {
45889     try {
45890       (arg1)->clear();
45891     } catch (std::out_of_range& e) {
45892       {
45893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45894       };
45895     } catch (std::exception& e) {
45896       {
45897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45898       };
45899     } catch (Dali::DaliException e) {
45900       {
45901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45902       };
45903     } catch (...) {
45904       {
45905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45906       };
45907     }
45908   }
45909
45910 }
45911
45912
45913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
45914   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45915   Dali::TouchPoint *arg2 = 0 ;
45916
45917   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45918   arg2 = (Dali::TouchPoint *)jarg2;
45919   if (!arg2) {
45920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45921     return ;
45922   }
45923   {
45924     try {
45925       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
45926     } catch (std::out_of_range& e) {
45927       {
45928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45929       };
45930     } catch (std::exception& e) {
45931       {
45932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45933       };
45934     } catch (Dali::DaliException e) {
45935       {
45936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45937       };
45938     } catch (...) {
45939       {
45940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45941       };
45942     }
45943   }
45944
45945 }
45946
45947
45948 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
45949   unsigned long jresult ;
45950   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45951   std::vector< Dali::TouchPoint >::size_type result;
45952
45953   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45954   {
45955     try {
45956       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
45957     } catch (std::out_of_range& e) {
45958       {
45959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45960       };
45961     } catch (std::exception& e) {
45962       {
45963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45964       };
45965     } catch (Dali::DaliException e) {
45966       {
45967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45968       };
45969     } catch (...) {
45970       {
45971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45972       };
45973     }
45974   }
45975
45976   jresult = (unsigned long)result;
45977   return jresult;
45978 }
45979
45980
45981 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
45982   unsigned long jresult ;
45983   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45984   std::vector< Dali::TouchPoint >::size_type result;
45985
45986   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45987   {
45988     try {
45989       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
45990     } catch (std::out_of_range& e) {
45991       {
45992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45993       };
45994     } catch (std::exception& e) {
45995       {
45996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45997       };
45998     } catch (Dali::DaliException e) {
45999       {
46000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46001       };
46002     } catch (...) {
46003       {
46004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46005       };
46006     }
46007   }
46008
46009   jresult = (unsigned long)result;
46010   return jresult;
46011 }
46012
46013
46014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
46015   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46016   std::vector< Dali::TouchPoint >::size_type arg2 ;
46017
46018   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46019   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
46020   {
46021     try {
46022       (arg1)->reserve(arg2);
46023     } catch (std::out_of_range& e) {
46024       {
46025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46026       };
46027     } catch (std::exception& e) {
46028       {
46029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46030       };
46031     } catch (Dali::DaliException e) {
46032       {
46033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46034       };
46035     } catch (...) {
46036       {
46037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46038       };
46039     }
46040   }
46041
46042 }
46043
46044
46045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
46046   void * jresult ;
46047   std::vector< Dali::TouchPoint > *result = 0 ;
46048
46049   {
46050     try {
46051       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
46052     } catch (std::out_of_range& e) {
46053       {
46054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46055       };
46056     } catch (std::exception& e) {
46057       {
46058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46059       };
46060     } catch (Dali::DaliException e) {
46061       {
46062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46063       };
46064     } catch (...) {
46065       {
46066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46067       };
46068     }
46069   }
46070
46071   jresult = (void *)result;
46072   return jresult;
46073 }
46074
46075
46076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
46077   void * jresult ;
46078   std::vector< Dali::TouchPoint > *arg1 = 0 ;
46079   std::vector< Dali::TouchPoint > *result = 0 ;
46080
46081   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46082   if (!arg1) {
46083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46084     return 0;
46085   }
46086   {
46087     try {
46088       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
46089     } catch (std::out_of_range& e) {
46090       {
46091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46092       };
46093     } catch (std::exception& e) {
46094       {
46095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46096       };
46097     } catch (Dali::DaliException e) {
46098       {
46099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46100       };
46101     } catch (...) {
46102       {
46103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46104       };
46105     }
46106   }
46107
46108   jresult = (void *)result;
46109   return jresult;
46110 }
46111
46112
46113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
46114   void * jresult ;
46115   int arg1 ;
46116   std::vector< Dali::TouchPoint > *result = 0 ;
46117
46118   arg1 = (int)jarg1;
46119   {
46120     try {
46121       try {
46122         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
46123       }
46124       catch(std::out_of_range &_e) {
46125         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46126         return 0;
46127       }
46128
46129     } catch (std::out_of_range& e) {
46130       {
46131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46132       };
46133     } catch (std::exception& e) {
46134       {
46135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46136       };
46137     } catch (Dali::DaliException e) {
46138       {
46139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46140       };
46141     } catch (...) {
46142       {
46143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46144       };
46145     }
46146   }
46147
46148   jresult = (void *)result;
46149   return jresult;
46150 }
46151
46152
46153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
46154   void * jresult ;
46155   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46156   int arg2 ;
46157   SwigValueWrapper< Dali::TouchPoint > result;
46158
46159   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46160   arg2 = (int)jarg2;
46161   {
46162     try {
46163       try {
46164         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
46165       }
46166       catch(std::out_of_range &_e) {
46167         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46168         return 0;
46169       }
46170
46171     } catch (std::out_of_range& e) {
46172       {
46173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46174       };
46175     } catch (std::exception& e) {
46176       {
46177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46178       };
46179     } catch (Dali::DaliException e) {
46180       {
46181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46182       };
46183     } catch (...) {
46184       {
46185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46186       };
46187     }
46188   }
46189
46190   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
46191   return jresult;
46192 }
46193
46194
46195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
46196   void * jresult ;
46197   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46198   int arg2 ;
46199   Dali::TouchPoint *result = 0 ;
46200
46201   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46202   arg2 = (int)jarg2;
46203   {
46204     try {
46205       try {
46206         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
46207       }
46208       catch(std::out_of_range &_e) {
46209         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46210         return 0;
46211       }
46212
46213     } catch (std::out_of_range& e) {
46214       {
46215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46216       };
46217     } catch (std::exception& e) {
46218       {
46219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46220       };
46221     } catch (Dali::DaliException e) {
46222       {
46223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46224       };
46225     } catch (...) {
46226       {
46227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46228       };
46229     }
46230   }
46231
46232   jresult = (void *)result;
46233   return jresult;
46234 }
46235
46236
46237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
46238   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46239   int arg2 ;
46240   Dali::TouchPoint *arg3 = 0 ;
46241
46242   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46243   arg2 = (int)jarg2;
46244   arg3 = (Dali::TouchPoint *)jarg3;
46245   if (!arg3) {
46246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46247     return ;
46248   }
46249   {
46250     try {
46251       try {
46252         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46253       }
46254       catch(std::out_of_range &_e) {
46255         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46256         return ;
46257       }
46258
46259     } catch (std::out_of_range& e) {
46260       {
46261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46262       };
46263     } catch (std::exception& e) {
46264       {
46265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46266       };
46267     } catch (Dali::DaliException e) {
46268       {
46269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46270       };
46271     } catch (...) {
46272       {
46273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46274       };
46275     }
46276   }
46277
46278 }
46279
46280
46281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
46282   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46283   std::vector< Dali::TouchPoint > *arg2 = 0 ;
46284
46285   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46286   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
46287   if (!arg2) {
46288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46289     return ;
46290   }
46291   {
46292     try {
46293       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
46294     } catch (std::out_of_range& e) {
46295       {
46296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46297       };
46298     } catch (std::exception& e) {
46299       {
46300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46301       };
46302     } catch (Dali::DaliException e) {
46303       {
46304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46305       };
46306     } catch (...) {
46307       {
46308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46309       };
46310     }
46311   }
46312
46313 }
46314
46315
46316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
46317   void * jresult ;
46318   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46319   int arg2 ;
46320   int arg3 ;
46321   std::vector< Dali::TouchPoint > *result = 0 ;
46322
46323   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46324   arg2 = (int)jarg2;
46325   arg3 = (int)jarg3;
46326   {
46327     try {
46328       try {
46329         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
46330       }
46331       catch(std::out_of_range &_e) {
46332         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46333         return 0;
46334       }
46335       catch(std::invalid_argument &_e) {
46336         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46337         return 0;
46338       }
46339
46340     } catch (std::out_of_range& e) {
46341       {
46342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46343       };
46344     } catch (std::exception& e) {
46345       {
46346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46347       };
46348     } catch (Dali::DaliException e) {
46349       {
46350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46351       };
46352     } catch (...) {
46353       {
46354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46355       };
46356     }
46357   }
46358
46359   jresult = (void *)result;
46360   return jresult;
46361 }
46362
46363
46364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
46365   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46366   int arg2 ;
46367   Dali::TouchPoint *arg3 = 0 ;
46368
46369   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46370   arg2 = (int)jarg2;
46371   arg3 = (Dali::TouchPoint *)jarg3;
46372   if (!arg3) {
46373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46374     return ;
46375   }
46376   {
46377     try {
46378       try {
46379         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46380       }
46381       catch(std::out_of_range &_e) {
46382         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46383         return ;
46384       }
46385
46386     } catch (std::out_of_range& e) {
46387       {
46388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46389       };
46390     } catch (std::exception& e) {
46391       {
46392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46393       };
46394     } catch (Dali::DaliException e) {
46395       {
46396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46397       };
46398     } catch (...) {
46399       {
46400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46401       };
46402     }
46403   }
46404
46405 }
46406
46407
46408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
46409   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46410   int arg2 ;
46411   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46412
46413   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46414   arg2 = (int)jarg2;
46415   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46416   if (!arg3) {
46417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46418     return ;
46419   }
46420   {
46421     try {
46422       try {
46423         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46424       }
46425       catch(std::out_of_range &_e) {
46426         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46427         return ;
46428       }
46429
46430     } catch (std::out_of_range& e) {
46431       {
46432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46433       };
46434     } catch (std::exception& e) {
46435       {
46436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46437       };
46438     } catch (Dali::DaliException e) {
46439       {
46440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46441       };
46442     } catch (...) {
46443       {
46444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46445       };
46446     }
46447   }
46448
46449 }
46450
46451
46452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
46453   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46454   int arg2 ;
46455
46456   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46457   arg2 = (int)jarg2;
46458   {
46459     try {
46460       try {
46461         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
46462       }
46463       catch(std::out_of_range &_e) {
46464         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46465         return ;
46466       }
46467
46468     } catch (std::out_of_range& e) {
46469       {
46470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46471       };
46472     } catch (std::exception& e) {
46473       {
46474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46475       };
46476     } catch (Dali::DaliException e) {
46477       {
46478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46479       };
46480     } catch (...) {
46481       {
46482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46483       };
46484     }
46485   }
46486
46487 }
46488
46489
46490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
46491   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46492   int arg2 ;
46493   int arg3 ;
46494
46495   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46496   arg2 = (int)jarg2;
46497   arg3 = (int)jarg3;
46498   {
46499     try {
46500       try {
46501         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
46502       }
46503       catch(std::out_of_range &_e) {
46504         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46505         return ;
46506       }
46507       catch(std::invalid_argument &_e) {
46508         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46509         return ;
46510       }
46511
46512     } catch (std::out_of_range& e) {
46513       {
46514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46515       };
46516     } catch (std::exception& e) {
46517       {
46518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46519       };
46520     } catch (Dali::DaliException e) {
46521       {
46522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46523       };
46524     } catch (...) {
46525       {
46526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46527       };
46528     }
46529   }
46530
46531 }
46532
46533
46534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
46535   void * jresult ;
46536   Dali::TouchPoint *arg1 = 0 ;
46537   int arg2 ;
46538   std::vector< Dali::TouchPoint > *result = 0 ;
46539
46540   arg1 = (Dali::TouchPoint *)jarg1;
46541   if (!arg1) {
46542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46543     return 0;
46544   }
46545   arg2 = (int)jarg2;
46546   {
46547     try {
46548       try {
46549         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
46550       }
46551       catch(std::out_of_range &_e) {
46552         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46553         return 0;
46554       }
46555
46556     } catch (std::out_of_range& e) {
46557       {
46558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46559       };
46560     } catch (std::exception& e) {
46561       {
46562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46563       };
46564     } catch (Dali::DaliException e) {
46565       {
46566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46567       };
46568     } catch (...) {
46569       {
46570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46571       };
46572     }
46573   }
46574
46575   jresult = (void *)result;
46576   return jresult;
46577 }
46578
46579
46580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
46581   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46582
46583   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46584   {
46585     try {
46586       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
46587     } catch (std::out_of_range& e) {
46588       {
46589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46590       };
46591     } catch (std::exception& e) {
46592       {
46593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46594       };
46595     } catch (Dali::DaliException e) {
46596       {
46597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46598       };
46599     } catch (...) {
46600       {
46601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46602       };
46603     }
46604   }
46605
46606 }
46607
46608
46609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
46610   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46611   int arg2 ;
46612   int arg3 ;
46613
46614   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46615   arg2 = (int)jarg2;
46616   arg3 = (int)jarg3;
46617   {
46618     try {
46619       try {
46620         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
46621       }
46622       catch(std::out_of_range &_e) {
46623         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46624         return ;
46625       }
46626       catch(std::invalid_argument &_e) {
46627         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46628         return ;
46629       }
46630
46631     } catch (std::out_of_range& e) {
46632       {
46633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46634       };
46635     } catch (std::exception& e) {
46636       {
46637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46638       };
46639     } catch (Dali::DaliException e) {
46640       {
46641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46642       };
46643     } catch (...) {
46644       {
46645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46646       };
46647     }
46648   }
46649
46650 }
46651
46652
46653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
46654   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46655   int arg2 ;
46656   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46657
46658   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46659   arg2 = (int)jarg2;
46660   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46661   if (!arg3) {
46662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46663     return ;
46664   }
46665   {
46666     try {
46667       try {
46668         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46669       }
46670       catch(std::out_of_range &_e) {
46671         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46672         return ;
46673       }
46674
46675     } catch (std::out_of_range& e) {
46676       {
46677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46678       };
46679     } catch (std::exception& e) {
46680       {
46681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46682       };
46683     } catch (Dali::DaliException e) {
46684       {
46685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46686       };
46687     } catch (...) {
46688       {
46689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46690       };
46691     }
46692   }
46693
46694 }
46695
46696
46697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
46698   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46699
46700   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46701   {
46702     try {
46703       delete arg1;
46704     } catch (std::out_of_range& e) {
46705       {
46706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46707       };
46708     } catch (std::exception& e) {
46709       {
46710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46711       };
46712     } catch (Dali::DaliException e) {
46713       {
46714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46715       };
46716     } catch (...) {
46717       {
46718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46719       };
46720     }
46721   }
46722
46723 }
46724
46725
46726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
46727   void * jresult ;
46728   Dali::Rect< int > *result = 0 ;
46729
46730   {
46731     try {
46732       result = (Dali::Rect< int > *)new Dali::Rect< int >();
46733     } catch (std::out_of_range& e) {
46734       {
46735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46736       };
46737     } catch (std::exception& e) {
46738       {
46739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46740       };
46741     } catch (Dali::DaliException e) {
46742       {
46743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46744       };
46745     } catch (...) {
46746       {
46747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46748       };
46749     }
46750   }
46751
46752   jresult = (void *)result;
46753   return jresult;
46754 }
46755
46756
46757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
46758   void * jresult ;
46759   int arg1 ;
46760   int arg2 ;
46761   int arg3 ;
46762   int arg4 ;
46763   Dali::Rect< int > *result = 0 ;
46764
46765   arg1 = (int)jarg1;
46766   arg2 = (int)jarg2;
46767   arg3 = (int)jarg3;
46768   arg4 = (int)jarg4;
46769   {
46770     try {
46771       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
46772     } catch (std::out_of_range& e) {
46773       {
46774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46775       };
46776     } catch (std::exception& e) {
46777       {
46778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46779       };
46780     } catch (Dali::DaliException e) {
46781       {
46782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46783       };
46784     } catch (...) {
46785       {
46786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46787       };
46788     }
46789   }
46790
46791   jresult = (void *)result;
46792   return jresult;
46793 }
46794
46795
46796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
46797   void * jresult ;
46798   Dali::Rect< int > *arg1 = 0 ;
46799   Dali::Rect< int > *result = 0 ;
46800
46801   arg1 = (Dali::Rect< int > *)jarg1;
46802   if (!arg1) {
46803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46804     return 0;
46805   }
46806   {
46807     try {
46808       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
46809     } catch (std::out_of_range& e) {
46810       {
46811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46812       };
46813     } catch (std::exception& e) {
46814       {
46815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46816       };
46817     } catch (Dali::DaliException e) {
46818       {
46819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46820       };
46821     } catch (...) {
46822       {
46823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46824       };
46825     }
46826   }
46827
46828   jresult = (void *)result;
46829   return jresult;
46830 }
46831
46832
46833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
46834   void * jresult ;
46835   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46836   Dali::Rect< int > *arg2 = 0 ;
46837   Dali::Rect< int > *result = 0 ;
46838
46839   arg1 = (Dali::Rect< int > *)jarg1;
46840   arg2 = (Dali::Rect< int > *)jarg2;
46841   if (!arg2) {
46842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46843     return 0;
46844   }
46845   {
46846     try {
46847       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
46848     } catch (std::out_of_range& e) {
46849       {
46850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46851       };
46852     } catch (std::exception& e) {
46853       {
46854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46855       };
46856     } catch (Dali::DaliException e) {
46857       {
46858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46859       };
46860     } catch (...) {
46861       {
46862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46863       };
46864     }
46865   }
46866
46867   jresult = (void *)result;
46868   return jresult;
46869 }
46870
46871
46872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
46873   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46874   int arg2 ;
46875   int arg3 ;
46876   int arg4 ;
46877   int arg5 ;
46878
46879   arg1 = (Dali::Rect< int > *)jarg1;
46880   arg2 = (int)jarg2;
46881   arg3 = (int)jarg3;
46882   arg4 = (int)jarg4;
46883   arg5 = (int)jarg5;
46884   {
46885     try {
46886       (arg1)->Set(arg2,arg3,arg4,arg5);
46887     } catch (std::out_of_range& e) {
46888       {
46889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46890       };
46891     } catch (std::exception& e) {
46892       {
46893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46894       };
46895     } catch (Dali::DaliException e) {
46896       {
46897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46898       };
46899     } catch (...) {
46900       {
46901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46902       };
46903     }
46904   }
46905
46906 }
46907
46908
46909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
46910   unsigned int jresult ;
46911   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46912   bool result;
46913
46914   arg1 = (Dali::Rect< int > *)jarg1;
46915   {
46916     try {
46917       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
46918     } catch (std::out_of_range& e) {
46919       {
46920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46921       };
46922     } catch (std::exception& e) {
46923       {
46924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46925       };
46926     } catch (Dali::DaliException e) {
46927       {
46928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46929       };
46930     } catch (...) {
46931       {
46932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46933       };
46934     }
46935   }
46936
46937   jresult = result;
46938   return jresult;
46939 }
46940
46941
46942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
46943   int jresult ;
46944   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46945   int result;
46946
46947   arg1 = (Dali::Rect< int > *)jarg1;
46948   {
46949     try {
46950       result = (int)((Dali::Rect< int > const *)arg1)->Left();
46951     } catch (std::out_of_range& e) {
46952       {
46953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46954       };
46955     } catch (std::exception& e) {
46956       {
46957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46958       };
46959     } catch (Dali::DaliException e) {
46960       {
46961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46962       };
46963     } catch (...) {
46964       {
46965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46966       };
46967     }
46968   }
46969
46970   jresult = result;
46971   return jresult;
46972 }
46973
46974
46975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
46976   int jresult ;
46977   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46978   int result;
46979
46980   arg1 = (Dali::Rect< int > *)jarg1;
46981   {
46982     try {
46983       result = (int)((Dali::Rect< int > const *)arg1)->Right();
46984     } catch (std::out_of_range& e) {
46985       {
46986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46987       };
46988     } catch (std::exception& e) {
46989       {
46990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46991       };
46992     } catch (Dali::DaliException e) {
46993       {
46994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46995       };
46996     } catch (...) {
46997       {
46998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46999       };
47000     }
47001   }
47002
47003   jresult = result;
47004   return jresult;
47005 }
47006
47007
47008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
47009   int jresult ;
47010   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47011   int result;
47012
47013   arg1 = (Dali::Rect< int > *)jarg1;
47014   {
47015     try {
47016       result = (int)((Dali::Rect< int > const *)arg1)->Top();
47017     } catch (std::out_of_range& e) {
47018       {
47019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47020       };
47021     } catch (std::exception& e) {
47022       {
47023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47024       };
47025     } catch (Dali::DaliException e) {
47026       {
47027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47028       };
47029     } catch (...) {
47030       {
47031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47032       };
47033     }
47034   }
47035
47036   jresult = result;
47037   return jresult;
47038 }
47039
47040
47041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
47042   int jresult ;
47043   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47044   int result;
47045
47046   arg1 = (Dali::Rect< int > *)jarg1;
47047   {
47048     try {
47049       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
47050     } catch (std::out_of_range& e) {
47051       {
47052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47053       };
47054     } catch (std::exception& e) {
47055       {
47056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47057       };
47058     } catch (Dali::DaliException e) {
47059       {
47060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47061       };
47062     } catch (...) {
47063       {
47064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47065       };
47066     }
47067   }
47068
47069   jresult = result;
47070   return jresult;
47071 }
47072
47073
47074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
47075   int jresult ;
47076   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47077   int result;
47078
47079   arg1 = (Dali::Rect< int > *)jarg1;
47080   {
47081     try {
47082       result = (int)((Dali::Rect< int > const *)arg1)->Area();
47083     } catch (std::out_of_range& e) {
47084       {
47085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47086       };
47087     } catch (std::exception& e) {
47088       {
47089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47090       };
47091     } catch (Dali::DaliException e) {
47092       {
47093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47094       };
47095     } catch (...) {
47096       {
47097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47098       };
47099     }
47100   }
47101
47102   jresult = result;
47103   return jresult;
47104 }
47105
47106
47107 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
47108   unsigned int jresult ;
47109   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47110   Dali::Rect< int > *arg2 = 0 ;
47111   bool result;
47112
47113   arg1 = (Dali::Rect< int > *)jarg1;
47114   arg2 = (Dali::Rect< int > *)jarg2;
47115   if (!arg2) {
47116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47117     return 0;
47118   }
47119   {
47120     try {
47121       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
47122     } catch (std::out_of_range& e) {
47123       {
47124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47125       };
47126     } catch (std::exception& e) {
47127       {
47128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47129       };
47130     } catch (Dali::DaliException e) {
47131       {
47132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47133       };
47134     } catch (...) {
47135       {
47136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47137       };
47138     }
47139   }
47140
47141   jresult = result;
47142   return jresult;
47143 }
47144
47145
47146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
47147   unsigned int jresult ;
47148   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47149   Dali::Rect< int > *arg2 = 0 ;
47150   bool result;
47151
47152   arg1 = (Dali::Rect< int > *)jarg1;
47153   arg2 = (Dali::Rect< int > *)jarg2;
47154   if (!arg2) {
47155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47156     return 0;
47157   }
47158   {
47159     try {
47160       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
47161     } catch (std::out_of_range& e) {
47162       {
47163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47164       };
47165     } catch (std::exception& e) {
47166       {
47167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47168       };
47169     } catch (Dali::DaliException e) {
47170       {
47171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47172       };
47173     } catch (...) {
47174       {
47175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47176       };
47177     }
47178   }
47179
47180   jresult = result;
47181   return jresult;
47182 }
47183
47184
47185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
47186   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47187   int arg2 ;
47188
47189   arg1 = (Dali::Rect< int > *)jarg1;
47190   arg2 = (int)jarg2;
47191   if (arg1) (arg1)->x = arg2;
47192 }
47193
47194
47195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
47196   int jresult ;
47197   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47198   int result;
47199
47200   arg1 = (Dali::Rect< int > *)jarg1;
47201   result = (int) ((arg1)->x);
47202   jresult = result;
47203   return jresult;
47204 }
47205
47206
47207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
47208   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47209   int arg2 ;
47210
47211   arg1 = (Dali::Rect< int > *)jarg1;
47212   arg2 = (int)jarg2;
47213   if (arg1) (arg1)->left = arg2;
47214 }
47215
47216
47217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
47218   int jresult ;
47219   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47220   int result;
47221
47222   arg1 = (Dali::Rect< int > *)jarg1;
47223   result = (int) ((arg1)->left);
47224   jresult = result;
47225   return jresult;
47226 }
47227
47228
47229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
47230   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47231   int arg2 ;
47232
47233   arg1 = (Dali::Rect< int > *)jarg1;
47234   arg2 = (int)jarg2;
47235   if (arg1) (arg1)->y = arg2;
47236 }
47237
47238
47239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
47240   int jresult ;
47241   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47242   int result;
47243
47244   arg1 = (Dali::Rect< int > *)jarg1;
47245   result = (int) ((arg1)->y);
47246   jresult = result;
47247   return jresult;
47248 }
47249
47250
47251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
47252   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47253   int arg2 ;
47254
47255   arg1 = (Dali::Rect< int > *)jarg1;
47256   arg2 = (int)jarg2;
47257   if (arg1) (arg1)->right = arg2;
47258 }
47259
47260
47261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
47262   int jresult ;
47263   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47264   int result;
47265
47266   arg1 = (Dali::Rect< int > *)jarg1;
47267   result = (int) ((arg1)->right);
47268   jresult = result;
47269   return jresult;
47270 }
47271
47272
47273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
47274   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47275   int arg2 ;
47276
47277   arg1 = (Dali::Rect< int > *)jarg1;
47278   arg2 = (int)jarg2;
47279   if (arg1) (arg1)->width = arg2;
47280 }
47281
47282
47283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
47284   int jresult ;
47285   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47286   int result;
47287
47288   arg1 = (Dali::Rect< int > *)jarg1;
47289   result = (int) ((arg1)->width);
47290   jresult = result;
47291   return jresult;
47292 }
47293
47294
47295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
47296   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47297   int arg2 ;
47298
47299   arg1 = (Dali::Rect< int > *)jarg1;
47300   arg2 = (int)jarg2;
47301   if (arg1) (arg1)->bottom = arg2;
47302 }
47303
47304
47305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
47306   int jresult ;
47307   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47308   int result;
47309
47310   arg1 = (Dali::Rect< int > *)jarg1;
47311   result = (int) ((arg1)->bottom);
47312   jresult = result;
47313   return jresult;
47314 }
47315
47316
47317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
47318   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47319   int arg2 ;
47320
47321   arg1 = (Dali::Rect< int > *)jarg1;
47322   arg2 = (int)jarg2;
47323   if (arg1) (arg1)->height = arg2;
47324 }
47325
47326
47327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
47328   int jresult ;
47329   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47330   int result;
47331
47332   arg1 = (Dali::Rect< int > *)jarg1;
47333   result = (int) ((arg1)->height);
47334   jresult = result;
47335   return jresult;
47336 }
47337
47338
47339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
47340   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47341   int arg2 ;
47342
47343   arg1 = (Dali::Rect< int > *)jarg1;
47344   arg2 = (int)jarg2;
47345   if (arg1) (arg1)->top = arg2;
47346 }
47347
47348
47349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
47350   int jresult ;
47351   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47352   int result;
47353
47354   arg1 = (Dali::Rect< int > *)jarg1;
47355   result = (int) ((arg1)->top);
47356   jresult = result;
47357   return jresult;
47358 }
47359
47360
47361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
47362   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47363
47364   arg1 = (Dali::Rect< int > *)jarg1;
47365   {
47366     try {
47367       delete arg1;
47368     } catch (std::out_of_range& e) {
47369       {
47370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47371       };
47372     } catch (std::exception& e) {
47373       {
47374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47375       };
47376     } catch (Dali::DaliException e) {
47377       {
47378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47379       };
47380     } catch (...) {
47381       {
47382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47383       };
47384     }
47385   }
47386
47387 }
47388
47389
47390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
47391   void * jresult ;
47392   Dali::Rect< float > *result = 0 ;
47393
47394   {
47395     try {
47396       result = (Dali::Rect< float > *)new Dali::Rect< float >();
47397     } catch (std::out_of_range& e) {
47398       {
47399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47400       };
47401     } catch (std::exception& e) {
47402       {
47403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47404       };
47405     } catch (Dali::DaliException e) {
47406       {
47407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47408       };
47409     } catch (...) {
47410       {
47411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47412       };
47413     }
47414   }
47415
47416   jresult = (void *)result;
47417   return jresult;
47418 }
47419
47420
47421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
47422   void * jresult ;
47423   float arg1 ;
47424   float arg2 ;
47425   float arg3 ;
47426   float arg4 ;
47427   Dali::Rect< float > *result = 0 ;
47428
47429   arg1 = (float)jarg1;
47430   arg2 = (float)jarg2;
47431   arg3 = (float)jarg4;
47432   arg4 = (float)jarg3;
47433   {
47434     try {
47435       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
47436     } catch (std::out_of_range& e) {
47437       {
47438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47439       };
47440     } catch (std::exception& e) {
47441       {
47442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47443       };
47444     } catch (Dali::DaliException e) {
47445       {
47446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47447       };
47448     } catch (...) {
47449       {
47450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47451       };
47452     }
47453   }
47454
47455   jresult = (void *)result;
47456   return jresult;
47457 }
47458
47459
47460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
47461   void * jresult ;
47462   Dali::Rect< float > *arg1 = 0 ;
47463   Dali::Rect< float > *result = 0 ;
47464
47465   arg1 = (Dali::Rect< float > *)jarg1;
47466   if (!arg1) {
47467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47468     return 0;
47469   }
47470   {
47471     try {
47472       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
47473     } catch (std::out_of_range& e) {
47474       {
47475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47476       };
47477     } catch (std::exception& e) {
47478       {
47479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47480       };
47481     } catch (Dali::DaliException e) {
47482       {
47483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47484       };
47485     } catch (...) {
47486       {
47487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47488       };
47489     }
47490   }
47491
47492   jresult = (void *)result;
47493   return jresult;
47494 }
47495
47496
47497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
47498   void * jresult ;
47499   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47500   Dali::Rect< float > *arg2 = 0 ;
47501   Dali::Rect< float > *result = 0 ;
47502
47503   arg1 = (Dali::Rect< float > *)jarg1;
47504   arg2 = (Dali::Rect< float > *)jarg2;
47505   if (!arg2) {
47506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47507     return 0;
47508   }
47509   {
47510     try {
47511       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
47512     } catch (std::out_of_range& e) {
47513       {
47514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47515       };
47516     } catch (std::exception& e) {
47517       {
47518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47519       };
47520     } catch (Dali::DaliException e) {
47521       {
47522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47523       };
47524     } catch (...) {
47525       {
47526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47527       };
47528     }
47529   }
47530
47531   jresult = (void *)result;
47532   return jresult;
47533 }
47534
47535
47536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
47537   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47538   float arg2 ;
47539   float arg3 ;
47540   float arg4 ;
47541   float arg5 ;
47542
47543   arg1 = (Dali::Rect< float > *)jarg1;
47544   arg2 = (float)jarg2;
47545   arg3 = (float)jarg3;
47546   arg4 = (float)jarg5;
47547   arg5 = (float)jarg4;
47548   {
47549     try {
47550       (arg1)->Set(arg2,arg3,arg4,arg5);
47551     } catch (std::out_of_range& e) {
47552       {
47553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47554       };
47555     } catch (std::exception& e) {
47556       {
47557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47558       };
47559     } catch (Dali::DaliException e) {
47560       {
47561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47562       };
47563     } catch (...) {
47564       {
47565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47566       };
47567     }
47568   }
47569
47570 }
47571
47572
47573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
47574   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47575   float arg2 ;
47576
47577   arg1 = (Dali::Rect< float > *)jarg1;
47578   arg2 = (float)jarg2;
47579   if (arg1) (arg1)->left = arg2;
47580 }
47581
47582
47583 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
47584   float jresult ;
47585   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47586   float result;
47587
47588   arg1 = (Dali::Rect< float > *)jarg1;
47589   result = (float) ((arg1)->left);
47590   jresult = result;
47591   return jresult;
47592 }
47593
47594
47595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
47596   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47597   float arg2 ;
47598
47599   arg1 = (Dali::Rect< float > *)jarg1;
47600   arg2 = (float)jarg2;
47601   if (arg1) (arg1)->left = arg2;
47602 }
47603
47604
47605 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
47606   float jresult ;
47607   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47608   float result;
47609
47610   arg1 = (Dali::Rect< float > *)jarg1;
47611   result = (float) ((arg1)->left);
47612   jresult = result;
47613   return jresult;
47614 }
47615
47616
47617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
47618   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47619   float arg2 ;
47620
47621   arg1 = (Dali::Rect< float > *)jarg1;
47622   arg2 = (float)jarg2;
47623   if (arg1) (arg1)->right = arg2;
47624 }
47625
47626
47627 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
47628   float jresult ;
47629   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47630   float result;
47631
47632   arg1 = (Dali::Rect< float > *)jarg1;
47633   result = (float) ((arg1)->right);
47634   jresult = result;
47635   return jresult;
47636 }
47637
47638
47639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
47640   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47641   float arg2 ;
47642
47643   arg1 = (Dali::Rect< float > *)jarg1;
47644   arg2 = (float)jarg2;
47645   if (arg1) (arg1)->right = arg2;
47646 }
47647
47648
47649 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
47650   float jresult ;
47651   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47652   float result;
47653
47654   arg1 = (Dali::Rect< float > *)jarg1;
47655   result = (float) ((arg1)->right);
47656   jresult = result;
47657   return jresult;
47658 }
47659
47660
47661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
47662   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47663   float arg2 ;
47664
47665   arg1 = (Dali::Rect< float > *)jarg1;
47666   arg2 = (float)jarg2;
47667   if (arg1) (arg1)->bottom = arg2;
47668 }
47669
47670
47671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
47672   float jresult ;
47673   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47674   float result;
47675
47676   arg1 = (Dali::Rect< float > *)jarg1;
47677   result = (float) ((arg1)->bottom);
47678   jresult = result;
47679   return jresult;
47680 }
47681
47682
47683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
47684   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47685   float arg2 ;
47686
47687   arg1 = (Dali::Rect< float > *)jarg1;
47688   arg2 = (float)jarg2;
47689   if (arg1) (arg1)->top = arg2;
47690 }
47691
47692
47693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
47694   float jresult ;
47695   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47696   float result;
47697
47698   arg1 = (Dali::Rect< float > *)jarg1;
47699   result = (float) ((arg1)->top);
47700   jresult = result;
47701   return jresult;
47702 }
47703
47704
47705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
47706   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47707
47708   arg1 = (Dali::Rect< float > *)jarg1;
47709   {
47710     try {
47711       delete arg1;
47712     } catch (std::out_of_range& e) {
47713       {
47714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47715       };
47716     } catch (std::exception& e) {
47717       {
47718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47719       };
47720     } catch (Dali::DaliException e) {
47721       {
47722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47723       };
47724     } catch (...) {
47725       {
47726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47727       };
47728     }
47729   }
47730
47731 }
47732
47733
47734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
47735   int jresult ;
47736   int result;
47737
47738   result = (int)Dali::Vector< int >::BaseType;
47739   jresult = (int)result;
47740   return jresult;
47741 }
47742
47743
47744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
47745   void * jresult ;
47746   Dali::Vector< int > *result = 0 ;
47747
47748   {
47749     try {
47750       result = (Dali::Vector< int > *)new Dali::Vector< int >();
47751     } catch (std::out_of_range& e) {
47752       {
47753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47754       };
47755     } catch (std::exception& e) {
47756       {
47757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47758       };
47759     } catch (Dali::DaliException e) {
47760       {
47761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47762       };
47763     } catch (...) {
47764       {
47765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47766       };
47767     }
47768   }
47769
47770   jresult = (void *)result;
47771   return jresult;
47772 }
47773
47774
47775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
47776   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47777
47778   arg1 = (Dali::Vector< int > *)jarg1;
47779   {
47780     try {
47781       delete arg1;
47782     } catch (std::out_of_range& e) {
47783       {
47784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47785       };
47786     } catch (std::exception& e) {
47787       {
47788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47789       };
47790     } catch (Dali::DaliException e) {
47791       {
47792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47793       };
47794     } catch (...) {
47795       {
47796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47797       };
47798     }
47799   }
47800
47801 }
47802
47803
47804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
47805   void * jresult ;
47806   Dali::Vector< int > *arg1 = 0 ;
47807   Dali::Vector< int > *result = 0 ;
47808
47809   arg1 = (Dali::Vector< int > *)jarg1;
47810   if (!arg1) {
47811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47812     return 0;
47813   }
47814   {
47815     try {
47816       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
47817     } catch (std::out_of_range& e) {
47818       {
47819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47820       };
47821     } catch (std::exception& e) {
47822       {
47823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47824       };
47825     } catch (Dali::DaliException e) {
47826       {
47827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47828       };
47829     } catch (...) {
47830       {
47831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47832       };
47833     }
47834   }
47835
47836   jresult = (void *)result;
47837   return jresult;
47838 }
47839
47840
47841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
47842   void * jresult ;
47843   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47844   Dali::Vector< int > *arg2 = 0 ;
47845   Dali::Vector< int > *result = 0 ;
47846
47847   arg1 = (Dali::Vector< int > *)jarg1;
47848   arg2 = (Dali::Vector< int > *)jarg2;
47849   if (!arg2) {
47850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47851     return 0;
47852   }
47853   {
47854     try {
47855       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
47856     } catch (std::out_of_range& e) {
47857       {
47858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47859       };
47860     } catch (std::exception& e) {
47861       {
47862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47863       };
47864     } catch (Dali::DaliException e) {
47865       {
47866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47867       };
47868     } catch (...) {
47869       {
47870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47871       };
47872     }
47873   }
47874
47875   jresult = (void *)result;
47876   return jresult;
47877 }
47878
47879
47880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
47881   void * jresult ;
47882   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47883   Dali::Vector< int >::Iterator result;
47884
47885   arg1 = (Dali::Vector< int > *)jarg1;
47886   {
47887     try {
47888       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
47889     } catch (std::out_of_range& e) {
47890       {
47891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47892       };
47893     } catch (std::exception& e) {
47894       {
47895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47896       };
47897     } catch (Dali::DaliException e) {
47898       {
47899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47900       };
47901     } catch (...) {
47902       {
47903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47904       };
47905     }
47906   }
47907
47908   jresult = (void *)result;
47909   return jresult;
47910 }
47911
47912
47913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
47914   void * jresult ;
47915   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47916   Dali::Vector< int >::Iterator result;
47917
47918   arg1 = (Dali::Vector< int > *)jarg1;
47919   {
47920     try {
47921       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
47922     } catch (std::out_of_range& e) {
47923       {
47924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47925       };
47926     } catch (std::exception& e) {
47927       {
47928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47929       };
47930     } catch (Dali::DaliException e) {
47931       {
47932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47933       };
47934     } catch (...) {
47935       {
47936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47937       };
47938     }
47939   }
47940
47941   jresult = (void *)result;
47942   return jresult;
47943 }
47944
47945
47946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47947   void * jresult ;
47948   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47949   Dali::Vector< int >::SizeType arg2 ;
47950   Dali::Vector< int >::ItemType *result = 0 ;
47951
47952   arg1 = (Dali::Vector< int > *)jarg1;
47953   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47954   {
47955     try {
47956       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
47957     } catch (std::out_of_range& e) {
47958       {
47959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47960       };
47961     } catch (std::exception& e) {
47962       {
47963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47964       };
47965     } catch (Dali::DaliException e) {
47966       {
47967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47968       };
47969     } catch (...) {
47970       {
47971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47972       };
47973     }
47974   }
47975
47976   jresult = (void *)result;
47977   return jresult;
47978 }
47979
47980
47981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
47982   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47983   Dali::Vector< int >::ItemType *arg2 = 0 ;
47984   Dali::Vector< int >::ItemType temp2 ;
47985
47986   arg1 = (Dali::Vector< int > *)jarg1;
47987   temp2 = (Dali::Vector< int >::ItemType)jarg2;
47988   arg2 = &temp2;
47989   {
47990     try {
47991       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
47992     } catch (std::out_of_range& e) {
47993       {
47994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47995       };
47996     } catch (std::exception& e) {
47997       {
47998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47999       };
48000     } catch (Dali::DaliException e) {
48001       {
48002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48003       };
48004     } catch (...) {
48005       {
48006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48007       };
48008     }
48009   }
48010
48011 }
48012
48013
48014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
48015   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48016   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48017   Dali::Vector< int >::ItemType *arg3 = 0 ;
48018   Dali::Vector< int >::ItemType temp3 ;
48019
48020   arg1 = (Dali::Vector< int > *)jarg1;
48021   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48022   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48023   arg3 = &temp3;
48024   {
48025     try {
48026       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48027     } catch (std::out_of_range& e) {
48028       {
48029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48030       };
48031     } catch (std::exception& e) {
48032       {
48033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48034       };
48035     } catch (Dali::DaliException e) {
48036       {
48037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48038       };
48039     } catch (...) {
48040       {
48041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48042       };
48043     }
48044   }
48045
48046 }
48047
48048
48049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48050   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48051   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48052   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48053   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
48054
48055   arg1 = (Dali::Vector< int > *)jarg1;
48056   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48057   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48058   arg4 = (Dali::Vector< int >::Iterator)jarg4;
48059   {
48060     try {
48061       (arg1)->Insert(arg2,arg3,arg4);
48062     } catch (std::out_of_range& e) {
48063       {
48064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48065       };
48066     } catch (std::exception& e) {
48067       {
48068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48069       };
48070     } catch (Dali::DaliException e) {
48071       {
48072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48073       };
48074     } catch (...) {
48075       {
48076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48077       };
48078     }
48079   }
48080
48081 }
48082
48083
48084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
48085   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48086   Dali::Vector< int >::SizeType arg2 ;
48087
48088   arg1 = (Dali::Vector< int > *)jarg1;
48089   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48090   {
48091     try {
48092       (arg1)->Reserve(arg2);
48093     } catch (std::out_of_range& e) {
48094       {
48095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48096       };
48097     } catch (std::exception& e) {
48098       {
48099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48100       };
48101     } catch (Dali::DaliException e) {
48102       {
48103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48104       };
48105     } catch (...) {
48106       {
48107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48108       };
48109     }
48110   }
48111
48112 }
48113
48114
48115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48116   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48117   Dali::Vector< int >::SizeType arg2 ;
48118
48119   arg1 = (Dali::Vector< int > *)jarg1;
48120   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48121   {
48122     try {
48123       (arg1)->Resize(arg2);
48124     } catch (std::out_of_range& e) {
48125       {
48126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48127       };
48128     } catch (std::exception& e) {
48129       {
48130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48131       };
48132     } catch (Dali::DaliException e) {
48133       {
48134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48135       };
48136     } catch (...) {
48137       {
48138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48139       };
48140     }
48141   }
48142
48143 }
48144
48145
48146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
48147   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48148   Dali::Vector< int >::SizeType arg2 ;
48149   Dali::Vector< int >::ItemType *arg3 = 0 ;
48150   Dali::Vector< int >::ItemType temp3 ;
48151
48152   arg1 = (Dali::Vector< int > *)jarg1;
48153   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48154   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48155   arg3 = &temp3;
48156   {
48157     try {
48158       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48159     } catch (std::out_of_range& e) {
48160       {
48161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48162       };
48163     } catch (std::exception& e) {
48164       {
48165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48166       };
48167     } catch (Dali::DaliException e) {
48168       {
48169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48170       };
48171     } catch (...) {
48172       {
48173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48174       };
48175     }
48176   }
48177
48178 }
48179
48180
48181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
48182   void * jresult ;
48183   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48184   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48185   Dali::Vector< int >::Iterator result;
48186
48187   arg1 = (Dali::Vector< int > *)jarg1;
48188   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48189   {
48190     try {
48191       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
48192     } catch (std::out_of_range& e) {
48193       {
48194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48195       };
48196     } catch (std::exception& e) {
48197       {
48198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48199       };
48200     } catch (Dali::DaliException e) {
48201       {
48202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48203       };
48204     } catch (...) {
48205       {
48206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48207       };
48208     }
48209   }
48210
48211   jresult = (void *)result;
48212   return jresult;
48213 }
48214
48215
48216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48217   void * jresult ;
48218   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48219   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48220   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48221   Dali::Vector< int >::Iterator result;
48222
48223   arg1 = (Dali::Vector< int > *)jarg1;
48224   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48225   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48226   {
48227     try {
48228       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
48229     } catch (std::out_of_range& e) {
48230       {
48231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48232       };
48233     } catch (std::exception& e) {
48234       {
48235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48236       };
48237     } catch (Dali::DaliException e) {
48238       {
48239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48240       };
48241     } catch (...) {
48242       {
48243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48244       };
48245     }
48246   }
48247
48248   jresult = (void *)result;
48249   return jresult;
48250 }
48251
48252
48253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
48254   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48255   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48256
48257   arg1 = (Dali::Vector< int > *)jarg1;
48258   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48259   {
48260     try {
48261       (arg1)->Remove(arg2);
48262     } catch (std::out_of_range& e) {
48263       {
48264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48265       };
48266     } catch (std::exception& e) {
48267       {
48268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48269       };
48270     } catch (Dali::DaliException e) {
48271       {
48272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48273       };
48274     } catch (...) {
48275       {
48276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48277       };
48278     }
48279   }
48280
48281 }
48282
48283
48284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
48285   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48286   Dali::Vector< int > *arg2 = 0 ;
48287
48288   arg1 = (Dali::Vector< int > *)jarg1;
48289   arg2 = (Dali::Vector< int > *)jarg2;
48290   if (!arg2) {
48291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
48292     return ;
48293   }
48294   {
48295     try {
48296       (arg1)->Swap(*arg2);
48297     } catch (std::out_of_range& e) {
48298       {
48299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48300       };
48301     } catch (std::exception& e) {
48302       {
48303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48304       };
48305     } catch (Dali::DaliException e) {
48306       {
48307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48308       };
48309     } catch (...) {
48310       {
48311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48312       };
48313     }
48314   }
48315
48316 }
48317
48318
48319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
48320   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48321
48322   arg1 = (Dali::Vector< int > *)jarg1;
48323   {
48324     try {
48325       (arg1)->Clear();
48326     } catch (std::out_of_range& e) {
48327       {
48328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48329       };
48330     } catch (std::exception& e) {
48331       {
48332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48333       };
48334     } catch (Dali::DaliException e) {
48335       {
48336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48337       };
48338     } catch (...) {
48339       {
48340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48341       };
48342     }
48343   }
48344
48345 }
48346
48347
48348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
48349   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48350
48351   arg1 = (Dali::Vector< int > *)jarg1;
48352   {
48353     try {
48354       (arg1)->Release();
48355     } catch (std::out_of_range& e) {
48356       {
48357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48358       };
48359     } catch (std::exception& e) {
48360       {
48361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48362       };
48363     } catch (Dali::DaliException e) {
48364       {
48365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48366       };
48367     } catch (...) {
48368       {
48369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48370       };
48371     }
48372   }
48373
48374 }
48375
48376
48377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
48378   int jresult ;
48379   int result;
48380
48381   result = (int)Dali::Vector< float >::BaseType;
48382   jresult = (int)result;
48383   return jresult;
48384 }
48385
48386
48387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
48388   void * jresult ;
48389   Dali::Vector< float > *result = 0 ;
48390
48391   {
48392     try {
48393       result = (Dali::Vector< float > *)new Dali::Vector< float >();
48394     } catch (std::out_of_range& e) {
48395       {
48396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48397       };
48398     } catch (std::exception& e) {
48399       {
48400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48401       };
48402     } catch (Dali::DaliException e) {
48403       {
48404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48405       };
48406     } catch (...) {
48407       {
48408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48409       };
48410     }
48411   }
48412
48413   jresult = (void *)result;
48414   return jresult;
48415 }
48416
48417
48418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
48419   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48420
48421   arg1 = (Dali::Vector< float > *)jarg1;
48422   {
48423     try {
48424       delete arg1;
48425     } catch (std::out_of_range& e) {
48426       {
48427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48428       };
48429     } catch (std::exception& e) {
48430       {
48431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48432       };
48433     } catch (Dali::DaliException e) {
48434       {
48435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48436       };
48437     } catch (...) {
48438       {
48439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48440       };
48441     }
48442   }
48443
48444 }
48445
48446
48447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
48448   void * jresult ;
48449   Dali::Vector< float > *arg1 = 0 ;
48450   Dali::Vector< float > *result = 0 ;
48451
48452   arg1 = (Dali::Vector< float > *)jarg1;
48453   if (!arg1) {
48454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48455     return 0;
48456   }
48457   {
48458     try {
48459       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
48460     } catch (std::out_of_range& e) {
48461       {
48462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48463       };
48464     } catch (std::exception& e) {
48465       {
48466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48467       };
48468     } catch (Dali::DaliException e) {
48469       {
48470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48471       };
48472     } catch (...) {
48473       {
48474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48475       };
48476     }
48477   }
48478
48479   jresult = (void *)result;
48480   return jresult;
48481 }
48482
48483
48484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
48485   void * jresult ;
48486   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48487   Dali::Vector< float > *arg2 = 0 ;
48488   Dali::Vector< float > *result = 0 ;
48489
48490   arg1 = (Dali::Vector< float > *)jarg1;
48491   arg2 = (Dali::Vector< float > *)jarg2;
48492   if (!arg2) {
48493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48494     return 0;
48495   }
48496   {
48497     try {
48498       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
48499     } catch (std::out_of_range& e) {
48500       {
48501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48502       };
48503     } catch (std::exception& e) {
48504       {
48505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48506       };
48507     } catch (Dali::DaliException e) {
48508       {
48509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48510       };
48511     } catch (...) {
48512       {
48513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48514       };
48515     }
48516   }
48517
48518   jresult = (void *)result;
48519   return jresult;
48520 }
48521
48522
48523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
48524   void * jresult ;
48525   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48526   Dali::Vector< float >::Iterator result;
48527
48528   arg1 = (Dali::Vector< float > *)jarg1;
48529   {
48530     try {
48531       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
48532     } catch (std::out_of_range& e) {
48533       {
48534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48535       };
48536     } catch (std::exception& e) {
48537       {
48538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48539       };
48540     } catch (Dali::DaliException e) {
48541       {
48542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48543       };
48544     } catch (...) {
48545       {
48546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48547       };
48548     }
48549   }
48550
48551   jresult = (void *)result;
48552   return jresult;
48553 }
48554
48555
48556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
48557   void * jresult ;
48558   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48559   Dali::Vector< float >::Iterator result;
48560
48561   arg1 = (Dali::Vector< float > *)jarg1;
48562   {
48563     try {
48564       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
48565     } catch (std::out_of_range& e) {
48566       {
48567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48568       };
48569     } catch (std::exception& e) {
48570       {
48571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48572       };
48573     } catch (Dali::DaliException e) {
48574       {
48575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48576       };
48577     } catch (...) {
48578       {
48579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48580       };
48581     }
48582   }
48583
48584   jresult = (void *)result;
48585   return jresult;
48586 }
48587
48588
48589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48590   void * jresult ;
48591   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48592   Dali::Vector< float >::SizeType arg2 ;
48593   Dali::Vector< float >::ItemType *result = 0 ;
48594
48595   arg1 = (Dali::Vector< float > *)jarg1;
48596   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48597   {
48598     try {
48599       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
48600     } catch (std::out_of_range& e) {
48601       {
48602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48603       };
48604     } catch (std::exception& e) {
48605       {
48606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48607       };
48608     } catch (Dali::DaliException e) {
48609       {
48610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48611       };
48612     } catch (...) {
48613       {
48614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48615       };
48616     }
48617   }
48618
48619   jresult = (void *)result;
48620   return jresult;
48621 }
48622
48623
48624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
48625   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48626   Dali::Vector< float >::ItemType *arg2 = 0 ;
48627   Dali::Vector< float >::ItemType temp2 ;
48628
48629   arg1 = (Dali::Vector< float > *)jarg1;
48630   temp2 = (Dali::Vector< float >::ItemType)jarg2;
48631   arg2 = &temp2;
48632   {
48633     try {
48634       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
48635     } catch (std::out_of_range& e) {
48636       {
48637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48638       };
48639     } catch (std::exception& e) {
48640       {
48641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48642       };
48643     } catch (Dali::DaliException e) {
48644       {
48645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48646       };
48647     } catch (...) {
48648       {
48649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48650       };
48651     }
48652   }
48653
48654 }
48655
48656
48657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
48658   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48659   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48660   Dali::Vector< float >::ItemType *arg3 = 0 ;
48661   Dali::Vector< float >::ItemType temp3 ;
48662
48663   arg1 = (Dali::Vector< float > *)jarg1;
48664   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48665   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48666   arg3 = &temp3;
48667   {
48668     try {
48669       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48670     } catch (std::out_of_range& e) {
48671       {
48672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48673       };
48674     } catch (std::exception& e) {
48675       {
48676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48677       };
48678     } catch (Dali::DaliException e) {
48679       {
48680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48681       };
48682     } catch (...) {
48683       {
48684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48685       };
48686     }
48687   }
48688
48689 }
48690
48691
48692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48693   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48694   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48695   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48696   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
48697
48698   arg1 = (Dali::Vector< float > *)jarg1;
48699   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48700   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48701   arg4 = (Dali::Vector< float >::Iterator)jarg4;
48702   {
48703     try {
48704       (arg1)->Insert(arg2,arg3,arg4);
48705     } catch (std::out_of_range& e) {
48706       {
48707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48708       };
48709     } catch (std::exception& e) {
48710       {
48711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48712       };
48713     } catch (Dali::DaliException e) {
48714       {
48715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48716       };
48717     } catch (...) {
48718       {
48719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48720       };
48721     }
48722   }
48723
48724 }
48725
48726
48727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
48728   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48729   Dali::Vector< float >::SizeType arg2 ;
48730
48731   arg1 = (Dali::Vector< float > *)jarg1;
48732   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48733   {
48734     try {
48735       (arg1)->Reserve(arg2);
48736     } catch (std::out_of_range& e) {
48737       {
48738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48739       };
48740     } catch (std::exception& e) {
48741       {
48742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48743       };
48744     } catch (Dali::DaliException e) {
48745       {
48746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48747       };
48748     } catch (...) {
48749       {
48750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48751       };
48752     }
48753   }
48754
48755 }
48756
48757 //// ========================= end of part 2 =============================
48758
48759 //// ========================== start part 3 ===============================
48760
48761
48762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48763   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48764   Dali::Vector< float >::SizeType arg2 ;
48765
48766   arg1 = (Dali::Vector< float > *)jarg1;
48767   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48768   {
48769     try {
48770       (arg1)->Resize(arg2);
48771     } catch (std::out_of_range& e) {
48772       {
48773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48774       };
48775     } catch (std::exception& e) {
48776       {
48777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48778       };
48779     } catch (Dali::DaliException e) {
48780       {
48781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48782       };
48783     } catch (...) {
48784       {
48785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48786       };
48787     }
48788   }
48789
48790 }
48791
48792
48793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
48794   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48795   Dali::Vector< float >::SizeType arg2 ;
48796   Dali::Vector< float >::ItemType *arg3 = 0 ;
48797   Dali::Vector< float >::ItemType temp3 ;
48798
48799   arg1 = (Dali::Vector< float > *)jarg1;
48800   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48801   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48802   arg3 = &temp3;
48803   {
48804     try {
48805       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48806     } catch (std::out_of_range& e) {
48807       {
48808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48809       };
48810     } catch (std::exception& e) {
48811       {
48812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48813       };
48814     } catch (Dali::DaliException e) {
48815       {
48816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48817       };
48818     } catch (...) {
48819       {
48820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48821       };
48822     }
48823   }
48824
48825 }
48826
48827
48828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
48829   void * jresult ;
48830   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48831   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48832   Dali::Vector< float >::Iterator result;
48833
48834   arg1 = (Dali::Vector< float > *)jarg1;
48835   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48836   {
48837     try {
48838       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
48839     } catch (std::out_of_range& e) {
48840       {
48841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48842       };
48843     } catch (std::exception& e) {
48844       {
48845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48846       };
48847     } catch (Dali::DaliException e) {
48848       {
48849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48850       };
48851     } catch (...) {
48852       {
48853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48854       };
48855     }
48856   }
48857
48858   jresult = (void *)result;
48859   return jresult;
48860 }
48861
48862
48863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48864   void * jresult ;
48865   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48866   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48867   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48868   Dali::Vector< float >::Iterator result;
48869
48870   arg1 = (Dali::Vector< float > *)jarg1;
48871   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48872   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48873   {
48874     try {
48875       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
48876     } catch (std::out_of_range& e) {
48877       {
48878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48879       };
48880     } catch (std::exception& e) {
48881       {
48882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48883       };
48884     } catch (Dali::DaliException e) {
48885       {
48886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48887       };
48888     } catch (...) {
48889       {
48890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48891       };
48892     }
48893   }
48894
48895   jresult = (void *)result;
48896   return jresult;
48897 }
48898
48899
48900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
48901   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48902   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48903
48904   arg1 = (Dali::Vector< float > *)jarg1;
48905   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48906   {
48907     try {
48908       (arg1)->Remove(arg2);
48909     } catch (std::out_of_range& e) {
48910       {
48911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48912       };
48913     } catch (std::exception& e) {
48914       {
48915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48916       };
48917     } catch (Dali::DaliException e) {
48918       {
48919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48920       };
48921     } catch (...) {
48922       {
48923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48924       };
48925     }
48926   }
48927
48928 }
48929
48930
48931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
48932   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48933   Dali::Vector< float > *arg2 = 0 ;
48934
48935   arg1 = (Dali::Vector< float > *)jarg1;
48936   arg2 = (Dali::Vector< float > *)jarg2;
48937   if (!arg2) {
48938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
48939     return ;
48940   }
48941   {
48942     try {
48943       (arg1)->Swap(*arg2);
48944     } catch (std::out_of_range& e) {
48945       {
48946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48947       };
48948     } catch (std::exception& e) {
48949       {
48950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48951       };
48952     } catch (Dali::DaliException e) {
48953       {
48954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48955       };
48956     } catch (...) {
48957       {
48958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48959       };
48960     }
48961   }
48962
48963 }
48964
48965
48966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
48967   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48968
48969   arg1 = (Dali::Vector< float > *)jarg1;
48970   {
48971     try {
48972       (arg1)->Clear();
48973     } catch (std::out_of_range& e) {
48974       {
48975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48976       };
48977     } catch (std::exception& e) {
48978       {
48979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48980       };
48981     } catch (Dali::DaliException e) {
48982       {
48983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48984       };
48985     } catch (...) {
48986       {
48987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48988       };
48989     }
48990   }
48991
48992 }
48993
48994
48995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
48996   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48997
48998   arg1 = (Dali::Vector< float > *)jarg1;
48999   {
49000     try {
49001       (arg1)->Release();
49002     } catch (std::out_of_range& e) {
49003       {
49004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49005       };
49006     } catch (std::exception& e) {
49007       {
49008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49009       };
49010     } catch (Dali::DaliException e) {
49011       {
49012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49013       };
49014     } catch (...) {
49015       {
49016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49017       };
49018     }
49019   }
49020
49021 }
49022
49023
49024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
49025   int jresult ;
49026   int result;
49027
49028   result = (int)Dali::Vector< unsigned char >::BaseType;
49029   jresult = (int)result;
49030   return jresult;
49031 }
49032
49033
49034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
49035   void * jresult ;
49036   Dali::Vector< unsigned char > *result = 0 ;
49037
49038   {
49039     try {
49040       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
49041     } catch (std::out_of_range& e) {
49042       {
49043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49044       };
49045     } catch (std::exception& e) {
49046       {
49047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49048       };
49049     } catch (Dali::DaliException e) {
49050       {
49051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49052       };
49053     } catch (...) {
49054       {
49055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49056       };
49057     }
49058   }
49059
49060   jresult = (void *)result;
49061   return jresult;
49062 }
49063
49064
49065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
49066   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49067
49068   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49069   {
49070     try {
49071       delete arg1;
49072     } catch (std::out_of_range& e) {
49073       {
49074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49075       };
49076     } catch (std::exception& e) {
49077       {
49078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49079       };
49080     } catch (Dali::DaliException e) {
49081       {
49082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49083       };
49084     } catch (...) {
49085       {
49086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49087       };
49088     }
49089   }
49090
49091 }
49092
49093
49094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
49095   void * jresult ;
49096   Dali::Vector< unsigned char > *arg1 = 0 ;
49097   Dali::Vector< unsigned char > *result = 0 ;
49098
49099   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49100   if (!arg1) {
49101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49102     return 0;
49103   }
49104   {
49105     try {
49106       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
49107     } catch (std::out_of_range& e) {
49108       {
49109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49110       };
49111     } catch (std::exception& e) {
49112       {
49113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49114       };
49115     } catch (Dali::DaliException e) {
49116       {
49117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49118       };
49119     } catch (...) {
49120       {
49121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49122       };
49123     }
49124   }
49125
49126   jresult = (void *)result;
49127   return jresult;
49128 }
49129
49130
49131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
49132   void * jresult ;
49133   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49134   Dali::Vector< unsigned char > *arg2 = 0 ;
49135   Dali::Vector< unsigned char > *result = 0 ;
49136
49137   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49138   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49139   if (!arg2) {
49140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49141     return 0;
49142   }
49143   {
49144     try {
49145       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
49146     } catch (std::out_of_range& e) {
49147       {
49148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49149       };
49150     } catch (std::exception& e) {
49151       {
49152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49153       };
49154     } catch (Dali::DaliException e) {
49155       {
49156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49157       };
49158     } catch (...) {
49159       {
49160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49161       };
49162     }
49163   }
49164
49165   jresult = (void *)result;
49166   return jresult;
49167 }
49168
49169
49170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
49171   void * jresult ;
49172   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49173   Dali::Vector< unsigned char >::Iterator result;
49174
49175   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49176   {
49177     try {
49178       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
49179     } catch (std::out_of_range& e) {
49180       {
49181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49182       };
49183     } catch (std::exception& e) {
49184       {
49185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49186       };
49187     } catch (Dali::DaliException e) {
49188       {
49189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49190       };
49191     } catch (...) {
49192       {
49193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49194       };
49195     }
49196   }
49197
49198   jresult = (void *)result;
49199   return jresult;
49200 }
49201
49202
49203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
49204   void * jresult ;
49205   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49206   Dali::Vector< unsigned char >::Iterator result;
49207
49208   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49209   {
49210     try {
49211       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
49212     } catch (std::out_of_range& e) {
49213       {
49214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49215       };
49216     } catch (std::exception& e) {
49217       {
49218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49219       };
49220     } catch (Dali::DaliException e) {
49221       {
49222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49223       };
49224     } catch (...) {
49225       {
49226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49227       };
49228     }
49229   }
49230
49231   jresult = (void *)result;
49232   return jresult;
49233 }
49234
49235
49236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49237   void * jresult ;
49238   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49239   Dali::Vector< unsigned char >::SizeType arg2 ;
49240   Dali::Vector< unsigned char >::ItemType *result = 0 ;
49241
49242   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49243   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49244   {
49245     try {
49246       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
49247     } catch (std::out_of_range& e) {
49248       {
49249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49250       };
49251     } catch (std::exception& e) {
49252       {
49253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49254       };
49255     } catch (Dali::DaliException e) {
49256       {
49257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49258       };
49259     } catch (...) {
49260       {
49261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49262       };
49263     }
49264   }
49265
49266   jresult = (void *)result;
49267   return jresult;
49268 }
49269
49270
49271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
49272   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49273   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
49274   Dali::Vector< unsigned char >::ItemType temp2 ;
49275
49276   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49277   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
49278   arg2 = &temp2;
49279   {
49280     try {
49281       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
49282     } catch (std::out_of_range& e) {
49283       {
49284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49285       };
49286     } catch (std::exception& e) {
49287       {
49288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49289       };
49290     } catch (Dali::DaliException e) {
49291       {
49292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49293       };
49294     } catch (...) {
49295       {
49296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49297       };
49298     }
49299   }
49300
49301 }
49302
49303
49304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
49305   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49306   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49307   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49308   Dali::Vector< unsigned char >::ItemType temp3 ;
49309
49310   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49311   arg2 = jarg2;
49312   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49313   arg3 = &temp3;
49314   {
49315     try {
49316       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49317     } catch (std::out_of_range& e) {
49318       {
49319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49320       };
49321     } catch (std::exception& e) {
49322       {
49323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49324       };
49325     } catch (Dali::DaliException e) {
49326       {
49327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49328       };
49329     } catch (...) {
49330       {
49331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49332       };
49333     }
49334   }
49335
49336
49337
49338 }
49339
49340
49341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
49342   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49343   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49344   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49345   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49346
49347   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49348   arg2 = jarg2;
49349   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49350   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
49351   {
49352     try {
49353       (arg1)->Insert(arg2,arg3,arg4);
49354     } catch (std::out_of_range& e) {
49355       {
49356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49357       };
49358     } catch (std::exception& e) {
49359       {
49360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49361       };
49362     } catch (Dali::DaliException e) {
49363       {
49364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49365       };
49366     } catch (...) {
49367       {
49368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49369       };
49370     }
49371   }
49372
49373
49374
49375 }
49376
49377
49378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
49379   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49380   Dali::Vector< unsigned char >::SizeType arg2 ;
49381
49382   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49383   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49384   {
49385     try {
49386       (arg1)->Reserve(arg2);
49387     } catch (std::out_of_range& e) {
49388       {
49389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49390       };
49391     } catch (std::exception& e) {
49392       {
49393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49394       };
49395     } catch (Dali::DaliException e) {
49396       {
49397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49398       };
49399     } catch (...) {
49400       {
49401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49402       };
49403     }
49404   }
49405
49406 }
49407
49408
49409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49410   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49411   Dali::Vector< unsigned char >::SizeType arg2 ;
49412
49413   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49414   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49415   {
49416     try {
49417       (arg1)->Resize(arg2);
49418     } catch (std::out_of_range& e) {
49419       {
49420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49421       };
49422     } catch (std::exception& e) {
49423       {
49424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49425       };
49426     } catch (Dali::DaliException e) {
49427       {
49428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49429       };
49430     } catch (...) {
49431       {
49432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49433       };
49434     }
49435   }
49436
49437 }
49438
49439
49440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
49441   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49442   Dali::Vector< unsigned char >::SizeType arg2 ;
49443   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49444   Dali::Vector< unsigned char >::ItemType temp3 ;
49445
49446   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49447   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49448   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49449   arg3 = &temp3;
49450   {
49451     try {
49452       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49453     } catch (std::out_of_range& e) {
49454       {
49455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49456       };
49457     } catch (std::exception& e) {
49458       {
49459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49460       };
49461     } catch (Dali::DaliException e) {
49462       {
49463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49464       };
49465     } catch (...) {
49466       {
49467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49468       };
49469     }
49470   }
49471
49472 }
49473
49474
49475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
49476   void * jresult ;
49477   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49478   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49479   Dali::Vector< unsigned char >::Iterator result;
49480
49481   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49482   arg2 = jarg2;
49483   {
49484     try {
49485       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
49486     } catch (std::out_of_range& e) {
49487       {
49488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49489       };
49490     } catch (std::exception& e) {
49491       {
49492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49493       };
49494     } catch (Dali::DaliException e) {
49495       {
49496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49497       };
49498     } catch (...) {
49499       {
49500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49501       };
49502     }
49503   }
49504
49505   jresult = (void *)result;
49506
49507
49508   return jresult;
49509 }
49510
49511
49512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
49513   void * jresult ;
49514   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49515   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49516   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49517   Dali::Vector< unsigned char >::Iterator result;
49518
49519   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49520   arg2 = jarg2;
49521   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49522   {
49523     try {
49524       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
49525     } catch (std::out_of_range& e) {
49526       {
49527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49528       };
49529     } catch (std::exception& e) {
49530       {
49531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49532       };
49533     } catch (Dali::DaliException e) {
49534       {
49535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49536       };
49537     } catch (...) {
49538       {
49539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49540       };
49541     }
49542   }
49543
49544   jresult = (void *)result;
49545
49546
49547   return jresult;
49548 }
49549
49550
49551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
49552   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49553   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49554
49555   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49556   arg2 = jarg2;
49557   {
49558     try {
49559       (arg1)->Remove(arg2);
49560     } catch (std::out_of_range& e) {
49561       {
49562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49563       };
49564     } catch (std::exception& e) {
49565       {
49566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49567       };
49568     } catch (Dali::DaliException e) {
49569       {
49570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49571       };
49572     } catch (...) {
49573       {
49574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49575       };
49576     }
49577   }
49578
49579
49580
49581 }
49582
49583
49584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
49585   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49586   Dali::Vector< unsigned char > *arg2 = 0 ;
49587
49588   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49589   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49590   if (!arg2) {
49591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
49592     return ;
49593   }
49594   {
49595     try {
49596       (arg1)->Swap(*arg2);
49597     } catch (std::out_of_range& e) {
49598       {
49599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49600       };
49601     } catch (std::exception& e) {
49602       {
49603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49604       };
49605     } catch (Dali::DaliException e) {
49606       {
49607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49608       };
49609     } catch (...) {
49610       {
49611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49612       };
49613     }
49614   }
49615
49616 }
49617
49618
49619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
49620   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49621
49622   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49623   {
49624     try {
49625       (arg1)->Clear();
49626     } catch (std::out_of_range& e) {
49627       {
49628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49629       };
49630     } catch (std::exception& e) {
49631       {
49632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49633       };
49634     } catch (Dali::DaliException e) {
49635       {
49636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49637       };
49638     } catch (...) {
49639       {
49640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49641       };
49642     }
49643   }
49644
49645 }
49646
49647
49648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
49649   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49650
49651   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49652   {
49653     try {
49654       (arg1)->Release();
49655     } catch (std::out_of_range& e) {
49656       {
49657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49658       };
49659     } catch (std::exception& e) {
49660       {
49661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49662       };
49663     } catch (Dali::DaliException e) {
49664       {
49665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49666       };
49667     } catch (...) {
49668       {
49669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49670       };
49671     }
49672   }
49673
49674 }
49675
49676
49677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
49678   int jresult ;
49679   int result;
49680
49681   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
49682   jresult = (int)result;
49683   return jresult;
49684 }
49685
49686
49687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
49688   void * jresult ;
49689   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49690
49691   {
49692     try {
49693       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
49694     } catch (std::out_of_range& e) {
49695       {
49696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49697       };
49698     } catch (std::exception& e) {
49699       {
49700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49701       };
49702     } catch (Dali::DaliException e) {
49703       {
49704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49705       };
49706     } catch (...) {
49707       {
49708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49709       };
49710     }
49711   }
49712
49713   jresult = (void *)result;
49714   return jresult;
49715 }
49716
49717
49718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
49719   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49720
49721   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49722   {
49723     try {
49724       delete arg1;
49725     } catch (std::out_of_range& e) {
49726       {
49727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49728       };
49729     } catch (std::exception& e) {
49730       {
49731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49732       };
49733     } catch (Dali::DaliException e) {
49734       {
49735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49736       };
49737     } catch (...) {
49738       {
49739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49740       };
49741     }
49742   }
49743
49744 }
49745
49746
49747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
49748   void * jresult ;
49749   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
49750   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49751
49752   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49753   if (!arg1) {
49754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49755     return 0;
49756   }
49757   {
49758     try {
49759       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
49760     } catch (std::out_of_range& e) {
49761       {
49762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49763       };
49764     } catch (std::exception& e) {
49765       {
49766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49767       };
49768     } catch (Dali::DaliException e) {
49769       {
49770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49771       };
49772     } catch (...) {
49773       {
49774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49775       };
49776     }
49777   }
49778
49779   jresult = (void *)result;
49780   return jresult;
49781 }
49782
49783
49784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
49785   void * jresult ;
49786   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49787   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
49788   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49789
49790   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49791   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
49792   if (!arg2) {
49793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49794     return 0;
49795   }
49796   {
49797     try {
49798       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
49799     } catch (std::out_of_range& e) {
49800       {
49801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49802       };
49803     } catch (std::exception& e) {
49804       {
49805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49806       };
49807     } catch (Dali::DaliException e) {
49808       {
49809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49810       };
49811     } catch (...) {
49812       {
49813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49814       };
49815     }
49816   }
49817
49818   jresult = (void *)result;
49819   return jresult;
49820 }
49821
49822
49823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
49824   void * jresult ;
49825   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49826   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49827
49828   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49829   {
49830     try {
49831       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
49832     } catch (std::out_of_range& e) {
49833       {
49834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49835       };
49836     } catch (std::exception& e) {
49837       {
49838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49839       };
49840     } catch (Dali::DaliException e) {
49841       {
49842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49843       };
49844     } catch (...) {
49845       {
49846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49847       };
49848     }
49849   }
49850
49851   jresult = (void *)result;
49852   return jresult;
49853 }
49854
49855
49856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
49857   void * jresult ;
49858   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49859   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49860
49861   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49862   {
49863     try {
49864       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
49865     } catch (std::out_of_range& e) {
49866       {
49867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49868       };
49869     } catch (std::exception& e) {
49870       {
49871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49872       };
49873     } catch (Dali::DaliException e) {
49874       {
49875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49876       };
49877     } catch (...) {
49878       {
49879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49880       };
49881     }
49882   }
49883
49884   jresult = (void *)result;
49885   return jresult;
49886 }
49887
49888
49889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49890   void * jresult ;
49891   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49892   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49893   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
49894
49895   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49896   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49897   {
49898     try {
49899       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
49900     } catch (std::out_of_range& e) {
49901       {
49902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49903       };
49904     } catch (std::exception& e) {
49905       {
49906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49907       };
49908     } catch (Dali::DaliException e) {
49909       {
49910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49911       };
49912     } catch (...) {
49913       {
49914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49915       };
49916     }
49917   }
49918
49919   jresult = (void *)result;
49920   return jresult;
49921 }
49922
49923
49924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
49925   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49926   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
49927
49928   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49929   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
49930   if (!arg2) {
49931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49932     return ;
49933   }
49934   {
49935     try {
49936       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
49937     } catch (std::out_of_range& e) {
49938       {
49939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49940       };
49941     } catch (std::exception& e) {
49942       {
49943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49944       };
49945     } catch (Dali::DaliException e) {
49946       {
49947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49948       };
49949     } catch (...) {
49950       {
49951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49952       };
49953     }
49954   }
49955
49956 }
49957
49958
49959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
49960   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49961   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49962   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
49963
49964   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49965   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49966   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
49967   if (!arg3) {
49968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49969     return ;
49970   }
49971   {
49972     try {
49973       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
49974     } catch (std::out_of_range& e) {
49975       {
49976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49977       };
49978     } catch (std::exception& e) {
49979       {
49980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49981       };
49982     } catch (Dali::DaliException e) {
49983       {
49984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49985       };
49986     } catch (...) {
49987       {
49988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49989       };
49990     }
49991   }
49992
49993 }
49994
49995
49996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
49997   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49998   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49999   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50000   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50001
50002   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50003   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50004   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50005   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
50006   {
50007     try {
50008       (arg1)->Insert(arg2,arg3,arg4);
50009     } catch (std::out_of_range& e) {
50010       {
50011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50012       };
50013     } catch (std::exception& e) {
50014       {
50015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50016       };
50017     } catch (Dali::DaliException e) {
50018       {
50019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50020       };
50021     } catch (...) {
50022       {
50023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50024       };
50025     }
50026   }
50027
50028 }
50029
50030
50031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
50032   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50033   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50034
50035   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50036   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50037   {
50038     try {
50039       (arg1)->Reserve(arg2);
50040     } catch (std::out_of_range& e) {
50041       {
50042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50043       };
50044     } catch (std::exception& e) {
50045       {
50046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50047       };
50048     } catch (Dali::DaliException e) {
50049       {
50050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50051       };
50052     } catch (...) {
50053       {
50054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50055       };
50056     }
50057   }
50058
50059 }
50060
50061
50062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
50063   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50064   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50065
50066   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50067   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50068   {
50069     try {
50070       (arg1)->Resize(arg2);
50071     } catch (std::out_of_range& e) {
50072       {
50073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50074       };
50075     } catch (std::exception& e) {
50076       {
50077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50078       };
50079     } catch (Dali::DaliException e) {
50080       {
50081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50082       };
50083     } catch (...) {
50084       {
50085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50086       };
50087     }
50088   }
50089
50090 }
50091
50092
50093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
50094   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50095   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50096   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
50097
50098   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50099   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50100   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
50101   if (!arg3) {
50102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50103     return ;
50104   }
50105   {
50106     try {
50107       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
50108     } catch (std::out_of_range& e) {
50109       {
50110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50111       };
50112     } catch (std::exception& e) {
50113       {
50114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50115       };
50116     } catch (Dali::DaliException e) {
50117       {
50118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50119       };
50120     } catch (...) {
50121       {
50122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50123       };
50124     }
50125   }
50126
50127 }
50128
50129
50130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
50131   void * jresult ;
50132   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50133   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50134   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50135
50136   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50137   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50138   {
50139     try {
50140       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
50141     } catch (std::out_of_range& e) {
50142       {
50143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50144       };
50145     } catch (std::exception& e) {
50146       {
50147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50148       };
50149     } catch (Dali::DaliException e) {
50150       {
50151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50152       };
50153     } catch (...) {
50154       {
50155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50156       };
50157     }
50158   }
50159
50160   jresult = (void *)result;
50161   return jresult;
50162 }
50163
50164
50165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
50166   void * jresult ;
50167   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50168   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50169   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50170   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50171
50172   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50173   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50174   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50175   {
50176     try {
50177       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
50178     } catch (std::out_of_range& e) {
50179       {
50180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50181       };
50182     } catch (std::exception& e) {
50183       {
50184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50185       };
50186     } catch (Dali::DaliException e) {
50187       {
50188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50189       };
50190     } catch (...) {
50191       {
50192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50193       };
50194     }
50195   }
50196
50197   jresult = (void *)result;
50198   return jresult;
50199 }
50200
50201
50202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
50203   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50204   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50205
50206   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50207   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50208   {
50209     try {
50210       (arg1)->Remove(arg2);
50211     } catch (std::out_of_range& e) {
50212       {
50213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50214       };
50215     } catch (std::exception& e) {
50216       {
50217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50218       };
50219     } catch (Dali::DaliException e) {
50220       {
50221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50222       };
50223     } catch (...) {
50224       {
50225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50226       };
50227     }
50228   }
50229
50230 }
50231
50232
50233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
50234   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50235   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
50236
50237   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50238   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
50239   if (!arg2) {
50240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
50241     return ;
50242   }
50243   {
50244     try {
50245       (arg1)->Swap(*arg2);
50246     } catch (std::out_of_range& e) {
50247       {
50248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50249       };
50250     } catch (std::exception& e) {
50251       {
50252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50253       };
50254     } catch (Dali::DaliException e) {
50255       {
50256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50257       };
50258     } catch (...) {
50259       {
50260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50261       };
50262     }
50263   }
50264
50265 }
50266
50267
50268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
50269   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50270
50271   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50272   {
50273     try {
50274       (arg1)->Clear();
50275     } catch (std::out_of_range& e) {
50276       {
50277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50278       };
50279     } catch (std::exception& e) {
50280       {
50281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50282       };
50283     } catch (Dali::DaliException e) {
50284       {
50285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50286       };
50287     } catch (...) {
50288       {
50289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50290       };
50291     }
50292   }
50293
50294 }
50295
50296
50297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
50298   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50299
50300   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50301   {
50302     try {
50303       (arg1)->Release();
50304     } catch (std::out_of_range& e) {
50305       {
50306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50307       };
50308     } catch (std::exception& e) {
50309       {
50310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50311       };
50312     } catch (Dali::DaliException e) {
50313       {
50314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50315       };
50316     } catch (...) {
50317       {
50318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50319       };
50320     }
50321   }
50322
50323 }
50324
50325
50326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
50327   void * jresult ;
50328   Dali::Signal< void () > *result = 0 ;
50329
50330   {
50331     try {
50332       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
50333     } catch (std::out_of_range& e) {
50334       {
50335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50336       };
50337     } catch (std::exception& e) {
50338       {
50339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50340       };
50341     } catch (Dali::DaliException e) {
50342       {
50343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50344       };
50345     } catch (...) {
50346       {
50347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50348       };
50349     }
50350   }
50351
50352   jresult = (void *)result;
50353   return jresult;
50354 }
50355
50356
50357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
50358   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50359
50360   arg1 = (Dali::Signal< void () > *)jarg1;
50361   {
50362     try {
50363       delete arg1;
50364     } catch (std::out_of_range& e) {
50365       {
50366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50367       };
50368     } catch (std::exception& e) {
50369       {
50370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50371       };
50372     } catch (Dali::DaliException e) {
50373       {
50374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50375       };
50376     } catch (...) {
50377       {
50378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50379       };
50380     }
50381   }
50382
50383 }
50384
50385
50386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
50387   unsigned int jresult ;
50388   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50389   bool result;
50390
50391   arg1 = (Dali::Signal< void () > *)jarg1;
50392   {
50393     try {
50394       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
50395     } catch (std::out_of_range& e) {
50396       {
50397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50398       };
50399     } catch (std::exception& e) {
50400       {
50401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50402       };
50403     } catch (Dali::DaliException e) {
50404       {
50405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50406       };
50407     } catch (...) {
50408       {
50409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50410       };
50411     }
50412   }
50413
50414   jresult = result;
50415   return jresult;
50416 }
50417
50418
50419 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
50420   unsigned long jresult ;
50421   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50422   std::size_t result;
50423
50424   arg1 = (Dali::Signal< void () > *)jarg1;
50425   {
50426     try {
50427       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
50428     } catch (std::out_of_range& e) {
50429       {
50430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50431       };
50432     } catch (std::exception& e) {
50433       {
50434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50435       };
50436     } catch (Dali::DaliException e) {
50437       {
50438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50439       };
50440     } catch (...) {
50441       {
50442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50443       };
50444     }
50445   }
50446
50447   jresult = (unsigned long)result;
50448   return jresult;
50449 }
50450
50451
50452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
50453   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50454   void (*arg2)() = (void (*)()) 0 ;
50455
50456   arg1 = (Dali::Signal< void () > *)jarg1;
50457   arg2 = (void (*)())jarg2;
50458   {
50459     try {
50460       (arg1)->Connect(arg2);
50461     } catch (std::out_of_range& e) {
50462       {
50463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50464       };
50465     } catch (std::exception& e) {
50466       {
50467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50468       };
50469     } catch (Dali::DaliException e) {
50470       {
50471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50472       };
50473     } catch (...) {
50474       {
50475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50476       };
50477     }
50478   }
50479
50480 }
50481
50482
50483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
50484   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50485   void (*arg2)() = (void (*)()) 0 ;
50486
50487   arg1 = (Dali::Signal< void () > *)jarg1;
50488   arg2 = (void (*)())jarg2;
50489   {
50490     try {
50491       (arg1)->Disconnect(arg2);
50492     } catch (std::out_of_range& e) {
50493       {
50494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50495       };
50496     } catch (std::exception& e) {
50497       {
50498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50499       };
50500     } catch (Dali::DaliException e) {
50501       {
50502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50503       };
50504     } catch (...) {
50505       {
50506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50507       };
50508     }
50509   }
50510
50511 }
50512
50513
50514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
50515   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50516   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
50517   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
50518
50519   arg1 = (Dali::Signal< void () > *)jarg1;
50520   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
50521   arg3 = (Dali::FunctorDelegate *)jarg3;
50522   {
50523     try {
50524       (arg1)->Connect(arg2,arg3);
50525     } catch (std::out_of_range& e) {
50526       {
50527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50528       };
50529     } catch (std::exception& e) {
50530       {
50531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50532       };
50533     } catch (Dali::DaliException e) {
50534       {
50535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50536       };
50537     } catch (...) {
50538       {
50539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50540       };
50541     }
50542   }
50543
50544 }
50545
50546
50547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
50548   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50549
50550   arg1 = (Dali::Signal< void () > *)jarg1;
50551   {
50552     try {
50553       (arg1)->Emit();
50554     } catch (std::out_of_range& e) {
50555       {
50556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50557       };
50558     } catch (std::exception& e) {
50559       {
50560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50561       };
50562     } catch (Dali::DaliException e) {
50563       {
50564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50565       };
50566     } catch (...) {
50567       {
50568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50569       };
50570     }
50571   }
50572
50573 }
50574
50575
50576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
50577   unsigned int jresult ;
50578   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50579   bool result;
50580
50581   arg1 = (Dali::Signal< void (float) > *)jarg1;
50582   {
50583     try {
50584       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
50585     } catch (std::out_of_range& e) {
50586       {
50587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50588       };
50589     } catch (std::exception& e) {
50590       {
50591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50592       };
50593     } catch (Dali::DaliException e) {
50594       {
50595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50596       };
50597     } catch (...) {
50598       {
50599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50600       };
50601     }
50602   }
50603
50604   jresult = result;
50605   return jresult;
50606 }
50607
50608
50609 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
50610   unsigned long jresult ;
50611   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50612   std::size_t result;
50613
50614   arg1 = (Dali::Signal< void (float) > *)jarg1;
50615   {
50616     try {
50617       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
50618     } catch (std::out_of_range& e) {
50619       {
50620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50621       };
50622     } catch (std::exception& e) {
50623       {
50624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50625       };
50626     } catch (Dali::DaliException e) {
50627       {
50628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50629       };
50630     } catch (...) {
50631       {
50632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50633       };
50634     }
50635   }
50636
50637   jresult = (unsigned long)result;
50638   return jresult;
50639 }
50640
50641
50642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
50643   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50644   void (*arg2)(float) = (void (*)(float)) 0 ;
50645
50646   arg1 = (Dali::Signal< void (float) > *)jarg1;
50647   arg2 = (void (*)(float))jarg2;
50648   {
50649     try {
50650       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
50651     } catch (std::out_of_range& e) {
50652       {
50653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50654       };
50655     } catch (std::exception& e) {
50656       {
50657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50658       };
50659     } catch (Dali::DaliException e) {
50660       {
50661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50662       };
50663     } catch (...) {
50664       {
50665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50666       };
50667     }
50668   }
50669
50670 }
50671
50672
50673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
50674   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50675   void (*arg2)(float) = (void (*)(float)) 0 ;
50676
50677   arg1 = (Dali::Signal< void (float) > *)jarg1;
50678   arg2 = (void (*)(float))jarg2;
50679   {
50680     try {
50681       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
50682     } catch (std::out_of_range& e) {
50683       {
50684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50685       };
50686     } catch (std::exception& e) {
50687       {
50688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50689       };
50690     } catch (Dali::DaliException e) {
50691       {
50692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50693       };
50694     } catch (...) {
50695       {
50696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50697       };
50698     }
50699   }
50700
50701 }
50702
50703
50704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
50705   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50706   float arg2 ;
50707
50708   arg1 = (Dali::Signal< void (float) > *)jarg1;
50709   arg2 = (float)jarg2;
50710   {
50711     try {
50712       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
50713     } catch (std::out_of_range& e) {
50714       {
50715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50716       };
50717     } catch (std::exception& e) {
50718       {
50719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50720       };
50721     } catch (Dali::DaliException e) {
50722       {
50723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50724       };
50725     } catch (...) {
50726       {
50727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50728       };
50729     }
50730   }
50731
50732 }
50733
50734
50735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
50736   void * jresult ;
50737   Dali::Signal< void (float) > *result = 0 ;
50738
50739   {
50740     try {
50741       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
50742     } catch (std::out_of_range& e) {
50743       {
50744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50745       };
50746     } catch (std::exception& e) {
50747       {
50748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50749       };
50750     } catch (Dali::DaliException e) {
50751       {
50752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50753       };
50754     } catch (...) {
50755       {
50756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50757       };
50758     }
50759   }
50760
50761   jresult = (void *)result;
50762   return jresult;
50763 }
50764
50765
50766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
50767   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50768
50769   arg1 = (Dali::Signal< void (float) > *)jarg1;
50770   {
50771     try {
50772       delete arg1;
50773     } catch (std::out_of_range& e) {
50774       {
50775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50776       };
50777     } catch (std::exception& e) {
50778       {
50779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50780       };
50781     } catch (Dali::DaliException e) {
50782       {
50783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50784       };
50785     } catch (...) {
50786       {
50787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50788       };
50789     }
50790   }
50791
50792 }
50793
50794
50795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
50796   unsigned int jresult ;
50797   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50798   bool result;
50799
50800   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50801   {
50802     try {
50803       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50804     } catch (std::out_of_range& e) {
50805       {
50806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50807       };
50808     } catch (std::exception& e) {
50809       {
50810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50811       };
50812     } catch (Dali::DaliException e) {
50813       {
50814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50815       };
50816     } catch (...) {
50817       {
50818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50819       };
50820     }
50821   }
50822
50823   jresult = result;
50824   return jresult;
50825 }
50826
50827
50828 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
50829   unsigned long jresult ;
50830   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50831   std::size_t result;
50832
50833   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50834   {
50835     try {
50836       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50837     } catch (std::out_of_range& e) {
50838       {
50839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50840       };
50841     } catch (std::exception& e) {
50842       {
50843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50844       };
50845     } catch (Dali::DaliException e) {
50846       {
50847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50848       };
50849     } catch (...) {
50850       {
50851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50852       };
50853     }
50854   }
50855
50856   jresult = (unsigned long)result;
50857   return jresult;
50858 }
50859
50860
50861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
50862   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50863   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50864
50865   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50866   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50867   {
50868     try {
50869       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
50870     } catch (std::out_of_range& e) {
50871       {
50872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50873       };
50874     } catch (std::exception& e) {
50875       {
50876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50877       };
50878     } catch (Dali::DaliException e) {
50879       {
50880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50881       };
50882     } catch (...) {
50883       {
50884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50885       };
50886     }
50887   }
50888
50889 }
50890
50891
50892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
50893   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50894   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50895
50896   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50897   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50898   {
50899     try {
50900       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
50901     } catch (std::out_of_range& e) {
50902       {
50903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50904       };
50905     } catch (std::exception& e) {
50906       {
50907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50908       };
50909     } catch (Dali::DaliException e) {
50910       {
50911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50912       };
50913     } catch (...) {
50914       {
50915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50916       };
50917     }
50918   }
50919
50920 }
50921
50922
50923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
50924   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50925   Dali::BaseHandle arg2 ;
50926   Dali::BaseHandle *argp2 ;
50927
50928   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50929   argp2 = (Dali::BaseHandle *)jarg2;
50930   if (!argp2) {
50931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50932     return ;
50933   }
50934   arg2 = *argp2;
50935   {
50936     try {
50937       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
50938     } catch (std::out_of_range& e) {
50939       {
50940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50941       };
50942     } catch (std::exception& e) {
50943       {
50944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50945       };
50946     } catch (Dali::DaliException e) {
50947       {
50948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50949       };
50950     } catch (...) {
50951       {
50952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50953       };
50954     }
50955   }
50956
50957 }
50958
50959
50960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
50961   void * jresult ;
50962   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
50963
50964   {
50965     try {
50966       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
50967     } catch (std::out_of_range& e) {
50968       {
50969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50970       };
50971     } catch (std::exception& e) {
50972       {
50973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50974       };
50975     } catch (Dali::DaliException e) {
50976       {
50977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50978       };
50979     } catch (...) {
50980       {
50981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50982       };
50983     }
50984   }
50985
50986   jresult = (void *)result;
50987   return jresult;
50988 }
50989
50990
50991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
50992   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50993
50994   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50995   {
50996     try {
50997       delete arg1;
50998     } catch (std::out_of_range& e) {
50999       {
51000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51001       };
51002     } catch (std::exception& e) {
51003       {
51004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51005       };
51006     } catch (Dali::DaliException e) {
51007       {
51008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51009       };
51010     } catch (...) {
51011       {
51012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51013       };
51014     }
51015   }
51016
51017 }
51018
51019
51020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
51021   unsigned int jresult ;
51022   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51023   bool result;
51024
51025   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51026   {
51027     try {
51028       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51029     } catch (std::out_of_range& e) {
51030       {
51031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51032       };
51033     } catch (std::exception& e) {
51034       {
51035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51036       };
51037     } catch (Dali::DaliException e) {
51038       {
51039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51040       };
51041     } catch (...) {
51042       {
51043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51044       };
51045     }
51046   }
51047
51048   jresult = result;
51049   return jresult;
51050 }
51051
51052
51053 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
51054   unsigned long jresult ;
51055   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51056   std::size_t result;
51057
51058   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51059   {
51060     try {
51061       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51062     } catch (std::out_of_range& e) {
51063       {
51064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51065       };
51066     } catch (std::exception& e) {
51067       {
51068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51069       };
51070     } catch (Dali::DaliException e) {
51071       {
51072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51073       };
51074     } catch (...) {
51075       {
51076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51077       };
51078     }
51079   }
51080
51081   jresult = (unsigned long)result;
51082   return jresult;
51083 }
51084
51085
51086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
51087   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51088   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51089
51090   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51091   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51092   {
51093     try {
51094       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
51095     } catch (std::out_of_range& e) {
51096       {
51097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51098       };
51099     } catch (std::exception& e) {
51100       {
51101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51102       };
51103     } catch (Dali::DaliException e) {
51104       {
51105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51106       };
51107     } catch (...) {
51108       {
51109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51110       };
51111     }
51112   }
51113
51114 }
51115
51116
51117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
51118   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51119   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51120
51121   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51122   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51123   {
51124     try {
51125       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
51126     } catch (std::out_of_range& e) {
51127       {
51128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51129       };
51130     } catch (std::exception& e) {
51131       {
51132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51133       };
51134     } catch (Dali::DaliException e) {
51135       {
51136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51137       };
51138     } catch (...) {
51139       {
51140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51141       };
51142     }
51143   }
51144
51145 }
51146
51147
51148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
51149   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51150   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
51151
51152   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51153   arg2 = (Dali::RefObject *)jarg2;
51154   {
51155     try {
51156       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
51157     } catch (std::out_of_range& e) {
51158       {
51159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51160       };
51161     } catch (std::exception& e) {
51162       {
51163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51164       };
51165     } catch (Dali::DaliException e) {
51166       {
51167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51168       };
51169     } catch (...) {
51170       {
51171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51172       };
51173     }
51174   }
51175
51176 }
51177
51178
51179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
51180   void * jresult ;
51181   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
51182
51183   {
51184     try {
51185       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
51186     } catch (std::out_of_range& e) {
51187       {
51188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51189       };
51190     } catch (std::exception& e) {
51191       {
51192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51193       };
51194     } catch (Dali::DaliException e) {
51195       {
51196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51197       };
51198     } catch (...) {
51199       {
51200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51201       };
51202     }
51203   }
51204
51205   jresult = (void *)result;
51206   return jresult;
51207 }
51208
51209
51210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
51211   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51212
51213   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51214   {
51215     try {
51216       delete arg1;
51217     } catch (std::out_of_range& e) {
51218       {
51219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51220       };
51221     } catch (std::exception& e) {
51222       {
51223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51224       };
51225     } catch (Dali::DaliException e) {
51226       {
51227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51228       };
51229     } catch (...) {
51230       {
51231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51232       };
51233     }
51234   }
51235
51236 }
51237
51238
51239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
51240   unsigned int jresult ;
51241   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51242   bool result;
51243
51244   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51245   {
51246     try {
51247       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51248     } catch (std::out_of_range& e) {
51249       {
51250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51251       };
51252     } catch (std::exception& e) {
51253       {
51254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51255       };
51256     } catch (Dali::DaliException e) {
51257       {
51258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51259       };
51260     } catch (...) {
51261       {
51262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51263       };
51264     }
51265   }
51266
51267   jresult = result;
51268   return jresult;
51269 }
51270
51271
51272 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
51273   unsigned long jresult ;
51274   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51275   std::size_t result;
51276
51277   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51278   {
51279     try {
51280       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51281     } catch (std::out_of_range& e) {
51282       {
51283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51284       };
51285     } catch (std::exception& e) {
51286       {
51287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51288       };
51289     } catch (Dali::DaliException e) {
51290       {
51291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51292       };
51293     } catch (...) {
51294       {
51295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51296       };
51297     }
51298   }
51299
51300   jresult = (unsigned long)result;
51301   return jresult;
51302 }
51303
51304
51305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
51306   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51307   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51308
51309   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51310   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51311   {
51312     try {
51313       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
51314     } catch (std::out_of_range& e) {
51315       {
51316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51317       };
51318     } catch (std::exception& e) {
51319       {
51320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51321       };
51322     } catch (Dali::DaliException e) {
51323       {
51324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51325       };
51326     } catch (...) {
51327       {
51328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51329       };
51330     }
51331   }
51332
51333 }
51334
51335
51336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
51337   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51338   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51339
51340   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51341   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51342   {
51343     try {
51344       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
51345     } catch (std::out_of_range& e) {
51346       {
51347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51348       };
51349     } catch (std::exception& e) {
51350       {
51351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51352       };
51353     } catch (Dali::DaliException e) {
51354       {
51355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51356       };
51357     } catch (...) {
51358       {
51359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51360       };
51361     }
51362   }
51363
51364 }
51365
51366
51367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
51368   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51369   Dali::PropertyNotification *arg2 = 0 ;
51370
51371   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51372   arg2 = (Dali::PropertyNotification *)jarg2;
51373   if (!arg2) {
51374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
51375     return ;
51376   }
51377   {
51378     try {
51379       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
51380     } catch (std::out_of_range& e) {
51381       {
51382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51383       };
51384     } catch (std::exception& e) {
51385       {
51386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51387       };
51388     } catch (Dali::DaliException e) {
51389       {
51390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51391       };
51392     } catch (...) {
51393       {
51394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51395       };
51396     }
51397   }
51398
51399 }
51400
51401
51402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
51403   void * jresult ;
51404   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
51405
51406   {
51407     try {
51408       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
51409     } catch (std::out_of_range& e) {
51410       {
51411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51412       };
51413     } catch (std::exception& e) {
51414       {
51415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51416       };
51417     } catch (Dali::DaliException e) {
51418       {
51419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51420       };
51421     } catch (...) {
51422       {
51423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51424       };
51425     }
51426   }
51427
51428   jresult = (void *)result;
51429   return jresult;
51430 }
51431
51432
51433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
51434   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51435
51436   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51437   {
51438     try {
51439       delete arg1;
51440     } catch (std::out_of_range& e) {
51441       {
51442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51443       };
51444     } catch (std::exception& e) {
51445       {
51446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51447       };
51448     } catch (Dali::DaliException e) {
51449       {
51450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51451       };
51452     } catch (...) {
51453       {
51454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51455       };
51456     }
51457   }
51458
51459 }
51460
51461
51462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
51463   void * jresult ;
51464   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
51465
51466   {
51467     try {
51468       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
51469     } catch (std::out_of_range& e) {
51470       {
51471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51472       };
51473     } catch (std::exception& e) {
51474       {
51475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51476       };
51477     } catch (Dali::DaliException e) {
51478       {
51479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51480       };
51481     } catch (...) {
51482       {
51483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51484       };
51485     }
51486   }
51487
51488   jresult = (void *)result;
51489   return jresult;
51490 }
51491
51492
51493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
51494   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
51495
51496   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
51497   {
51498     try {
51499       delete arg1;
51500     } catch (std::out_of_range& e) {
51501       {
51502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51503       };
51504     } catch (std::exception& e) {
51505       {
51506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51507       };
51508     } catch (Dali::DaliException e) {
51509       {
51510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51511       };
51512     } catch (...) {
51513       {
51514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51515       };
51516     }
51517   }
51518
51519 }
51520
51521
51522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
51523   unsigned int jresult ;
51524   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51525   bool result;
51526
51527   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51528   {
51529     try {
51530       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);
51531     } catch (std::out_of_range& e) {
51532       {
51533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51534       };
51535     } catch (std::exception& e) {
51536       {
51537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51538       };
51539     } catch (Dali::DaliException e) {
51540       {
51541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51542       };
51543     } catch (...) {
51544       {
51545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51546       };
51547     }
51548   }
51549
51550   jresult = result;
51551   return jresult;
51552 }
51553
51554
51555 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51556   unsigned long jresult ;
51557   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51558   std::size_t result;
51559
51560   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51561   {
51562     try {
51563       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);
51564     } catch (std::out_of_range& e) {
51565       {
51566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51567       };
51568     } catch (std::exception& e) {
51569       {
51570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51571       };
51572     } catch (Dali::DaliException e) {
51573       {
51574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51575       };
51576     } catch (...) {
51577       {
51578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51579       };
51580     }
51581   }
51582
51583   jresult = (unsigned long)result;
51584   return jresult;
51585 }
51586
51587
51588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51589   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51590   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51591
51592   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51593   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51594   {
51595     try {
51596       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51597     } catch (std::out_of_range& e) {
51598       {
51599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51600       };
51601     } catch (std::exception& e) {
51602       {
51603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51604       };
51605     } catch (Dali::DaliException e) {
51606       {
51607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51608       };
51609     } catch (...) {
51610       {
51611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51612       };
51613     }
51614   }
51615
51616 }
51617
51618
51619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51620   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51621   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51622
51623   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51624   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51625   {
51626     try {
51627       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51628     } catch (std::out_of_range& e) {
51629       {
51630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51631       };
51632     } catch (std::exception& e) {
51633       {
51634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51635       };
51636     } catch (Dali::DaliException e) {
51637       {
51638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51639       };
51640     } catch (...) {
51641       {
51642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51643       };
51644     }
51645   }
51646
51647 }
51648
51649
51650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51651   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51652   Dali::Actor arg2 ;
51653   Dali::LongPressGesture *arg3 = 0 ;
51654   Dali::Actor *argp2 ;
51655
51656   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51657   argp2 = (Dali::Actor *)jarg2;
51658   if (!argp2) {
51659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51660     return ;
51661   }
51662   arg2 = *argp2;
51663   arg3 = (Dali::LongPressGesture *)jarg3;
51664   if (!arg3) {
51665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
51666     return ;
51667   }
51668   {
51669     try {
51670       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
51671     } catch (std::out_of_range& e) {
51672       {
51673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51674       };
51675     } catch (std::exception& e) {
51676       {
51677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51678       };
51679     } catch (Dali::DaliException e) {
51680       {
51681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51682       };
51683     } catch (...) {
51684       {
51685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51686       };
51687     }
51688   }
51689
51690 }
51691
51692
51693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
51694   void * jresult ;
51695   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
51696
51697   {
51698     try {
51699       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
51700     } catch (std::out_of_range& e) {
51701       {
51702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51703       };
51704     } catch (std::exception& e) {
51705       {
51706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51707       };
51708     } catch (Dali::DaliException e) {
51709       {
51710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51711       };
51712     } catch (...) {
51713       {
51714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51715       };
51716     }
51717   }
51718
51719   jresult = (void *)result;
51720   return jresult;
51721 }
51722
51723
51724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
51725   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51726
51727   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51728   {
51729     try {
51730       delete arg1;
51731     } catch (std::out_of_range& e) {
51732       {
51733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51734       };
51735     } catch (std::exception& e) {
51736       {
51737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51738       };
51739     } catch (Dali::DaliException e) {
51740       {
51741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51742       };
51743     } catch (...) {
51744       {
51745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51746       };
51747     }
51748   }
51749
51750 }
51751
51752
51753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
51754   unsigned int jresult ;
51755   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51756   bool result;
51757
51758   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51759   {
51760     try {
51761       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *)arg1);
51762     } catch (std::out_of_range& e) {
51763       {
51764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51765       };
51766     } catch (std::exception& e) {
51767       {
51768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51769       };
51770     } catch (Dali::DaliException e) {
51771       {
51772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51773       };
51774     } catch (...) {
51775       {
51776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51777       };
51778     }
51779   }
51780
51781   jresult = result;
51782   return jresult;
51783 }
51784
51785
51786 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
51787   unsigned long jresult ;
51788   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51789   std::size_t result;
51790
51791   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51792   {
51793     try {
51794       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *)arg1);
51795     } catch (std::out_of_range& e) {
51796       {
51797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51798       };
51799     } catch (std::exception& e) {
51800       {
51801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51802       };
51803     } catch (Dali::DaliException e) {
51804       {
51805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51806       };
51807     } catch (...) {
51808       {
51809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51810       };
51811     }
51812   }
51813
51814   jresult = (unsigned long)result;
51815   return jresult;
51816 }
51817
51818
51819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
51820   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51821   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
51822
51823   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51824   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
51825   {
51826     try {
51827       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51828     } catch (std::out_of_range& e) {
51829       {
51830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51831       };
51832     } catch (std::exception& e) {
51833       {
51834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51835       };
51836     } catch (Dali::DaliException e) {
51837       {
51838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51839       };
51840     } catch (...) {
51841       {
51842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51843       };
51844     }
51845   }
51846
51847 }
51848
51849
51850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
51851   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51852   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
51853
51854   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51855   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
51856   {
51857     try {
51858       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51859     } catch (std::out_of_range& e) {
51860       {
51861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51862       };
51863     } catch (std::exception& e) {
51864       {
51865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51866       };
51867     } catch (Dali::DaliException e) {
51868       {
51869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51870       };
51871     } catch (...) {
51872       {
51873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51874       };
51875     }
51876   }
51877
51878 }
51879
51880
51881 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51882   unsigned int jresult ;
51883   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51884   Dali::Actor arg2 ;
51885   Dali::TouchEvent *arg3 = 0 ;
51886   Dali::Actor *argp2 ;
51887   bool result;
51888
51889   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51890   argp2 = (Dali::Actor *)jarg2;
51891   if (!argp2) {
51892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51893     return 0;
51894   }
51895   arg2 = *argp2;
51896   arg3 = (Dali::TouchEvent *)jarg3;
51897   if (!arg3) {
51898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
51899     return 0;
51900   }
51901   {
51902     try {
51903       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
51904     } catch (std::out_of_range& e) {
51905       {
51906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51907       };
51908     } catch (std::exception& e) {
51909       {
51910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51911       };
51912     } catch (Dali::DaliException e) {
51913       {
51914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51915       };
51916     } catch (...) {
51917       {
51918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51919       };
51920     }
51921   }
51922
51923   jresult = result;
51924   return jresult;
51925 }
51926
51927
51928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
51929   void * jresult ;
51930   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
51931
51932   {
51933     try {
51934       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
51935     } catch (std::out_of_range& e) {
51936       {
51937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51938       };
51939     } catch (std::exception& e) {
51940       {
51941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51942       };
51943     } catch (Dali::DaliException e) {
51944       {
51945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51946       };
51947     } catch (...) {
51948       {
51949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51950       };
51951     }
51952   }
51953
51954   jresult = (void *)result;
51955   return jresult;
51956 }
51957
51958
51959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
51960   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51961
51962   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51963   {
51964     try {
51965       delete arg1;
51966     } catch (std::out_of_range& e) {
51967       {
51968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51969       };
51970     } catch (std::exception& e) {
51971       {
51972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51973       };
51974     } catch (Dali::DaliException e) {
51975       {
51976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51977       };
51978     } catch (...) {
51979       {
51980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51981       };
51982     }
51983   }
51984
51985 }
51986
51987
51988 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
51989   unsigned int jresult ;
51990   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51991   bool result;
51992
51993   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51994   {
51995     try {
51996       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);
51997     } catch (std::out_of_range& e) {
51998       {
51999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52000       };
52001     } catch (std::exception& e) {
52002       {
52003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52004       };
52005     } catch (Dali::DaliException e) {
52006       {
52007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52008       };
52009     } catch (...) {
52010       {
52011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52012       };
52013     }
52014   }
52015
52016   jresult = result;
52017   return jresult;
52018 }
52019
52020
52021 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
52022   unsigned long jresult ;
52023   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52024   std::size_t result;
52025
52026   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52027   {
52028     try {
52029       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);
52030     } catch (std::out_of_range& e) {
52031       {
52032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52033       };
52034     } catch (std::exception& e) {
52035       {
52036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52037       };
52038     } catch (Dali::DaliException e) {
52039       {
52040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52041       };
52042     } catch (...) {
52043       {
52044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52045       };
52046     }
52047   }
52048
52049   jresult = (unsigned long)result;
52050   return jresult;
52051 }
52052
52053
52054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
52055   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52056   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52057
52058   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52059   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52060   {
52061     try {
52062       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52063     } catch (std::out_of_range& e) {
52064       {
52065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52066       };
52067     } catch (std::exception& e) {
52068       {
52069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52070       };
52071     } catch (Dali::DaliException e) {
52072       {
52073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52074       };
52075     } catch (...) {
52076       {
52077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52078       };
52079     }
52080   }
52081
52082 }
52083
52084
52085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
52086   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52087   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52088
52089   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52090   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52091   {
52092     try {
52093       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52094     } catch (std::out_of_range& e) {
52095       {
52096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52097       };
52098     } catch (std::exception& e) {
52099       {
52100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52101       };
52102     } catch (Dali::DaliException e) {
52103       {
52104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52105       };
52106     } catch (...) {
52107       {
52108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52109       };
52110     }
52111   }
52112
52113 }
52114
52115
52116 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52117   unsigned int jresult ;
52118   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52119   Dali::Actor arg2 ;
52120   Dali::HoverEvent *arg3 = 0 ;
52121   Dali::Actor *argp2 ;
52122   bool result;
52123
52124   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52125   argp2 = (Dali::Actor *)jarg2;
52126   if (!argp2) {
52127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52128     return 0;
52129   }
52130   arg2 = *argp2;
52131   arg3 = (Dali::HoverEvent *)jarg3;
52132   if (!arg3) {
52133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
52134     return 0;
52135   }
52136   {
52137     try {
52138       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
52139     } catch (std::out_of_range& e) {
52140       {
52141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52142       };
52143     } catch (std::exception& e) {
52144       {
52145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52146       };
52147     } catch (Dali::DaliException e) {
52148       {
52149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52150       };
52151     } catch (...) {
52152       {
52153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52154       };
52155     }
52156   }
52157
52158   jresult = result;
52159   return jresult;
52160 }
52161
52162
52163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
52164   void * jresult ;
52165   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
52166
52167   {
52168     try {
52169       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
52170     } catch (std::out_of_range& e) {
52171       {
52172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52173       };
52174     } catch (std::exception& e) {
52175       {
52176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52177       };
52178     } catch (Dali::DaliException e) {
52179       {
52180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52181       };
52182     } catch (...) {
52183       {
52184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52185       };
52186     }
52187   }
52188
52189   jresult = (void *)result;
52190   return jresult;
52191 }
52192
52193
52194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
52195   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52196
52197   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52198   {
52199     try {
52200       delete arg1;
52201     } catch (std::out_of_range& e) {
52202       {
52203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52204       };
52205     } catch (std::exception& e) {
52206       {
52207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52208       };
52209     } catch (Dali::DaliException e) {
52210       {
52211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52212       };
52213     } catch (...) {
52214       {
52215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52216       };
52217     }
52218   }
52219
52220 }
52221
52222
52223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
52224   unsigned int jresult ;
52225   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52226   bool result;
52227
52228   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52229   {
52230     try {
52231       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);
52232     } catch (std::out_of_range& e) {
52233       {
52234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52235       };
52236     } catch (std::exception& e) {
52237       {
52238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52239       };
52240     } catch (Dali::DaliException e) {
52241       {
52242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52243       };
52244     } catch (...) {
52245       {
52246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52247       };
52248     }
52249   }
52250
52251   jresult = result;
52252   return jresult;
52253 }
52254
52255
52256 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
52257   unsigned long jresult ;
52258   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52259   std::size_t result;
52260
52261   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52262   {
52263     try {
52264       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);
52265     } catch (std::out_of_range& e) {
52266       {
52267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52268       };
52269     } catch (std::exception& e) {
52270       {
52271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52272       };
52273     } catch (Dali::DaliException e) {
52274       {
52275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52276       };
52277     } catch (...) {
52278       {
52279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52280       };
52281     }
52282   }
52283
52284   jresult = (unsigned long)result;
52285   return jresult;
52286 }
52287
52288
52289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
52290   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52291   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52292
52293   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52294   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52295   {
52296     try {
52297       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52298     } catch (std::out_of_range& e) {
52299       {
52300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52301       };
52302     } catch (std::exception& e) {
52303       {
52304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52305       };
52306     } catch (Dali::DaliException e) {
52307       {
52308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52309       };
52310     } catch (...) {
52311       {
52312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52313       };
52314     }
52315   }
52316
52317 }
52318
52319
52320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
52321   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52322   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52323
52324   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52325   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52326   {
52327     try {
52328       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52329     } catch (std::out_of_range& e) {
52330       {
52331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52332       };
52333     } catch (std::exception& e) {
52334       {
52335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52336       };
52337     } catch (Dali::DaliException e) {
52338       {
52339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52340       };
52341     } catch (...) {
52342       {
52343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52344       };
52345     }
52346   }
52347
52348 }
52349
52350
52351 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52352   unsigned int jresult ;
52353   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52354   Dali::Actor arg2 ;
52355   Dali::WheelEvent *arg3 = 0 ;
52356   Dali::Actor *argp2 ;
52357   bool result;
52358
52359   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52360   argp2 = (Dali::Actor *)jarg2;
52361   if (!argp2) {
52362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52363     return 0;
52364   }
52365   arg2 = *argp2;
52366   arg3 = (Dali::WheelEvent *)jarg3;
52367   if (!arg3) {
52368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
52369     return 0;
52370   }
52371   {
52372     try {
52373       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
52374     } catch (std::out_of_range& e) {
52375       {
52376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52377       };
52378     } catch (std::exception& e) {
52379       {
52380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52381       };
52382     } catch (Dali::DaliException e) {
52383       {
52384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52385       };
52386     } catch (...) {
52387       {
52388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52389       };
52390     }
52391   }
52392
52393   jresult = result;
52394   return jresult;
52395 }
52396
52397
52398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
52399   void * jresult ;
52400   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
52401
52402   {
52403     try {
52404       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
52405     } catch (std::out_of_range& e) {
52406       {
52407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52408       };
52409     } catch (std::exception& e) {
52410       {
52411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52412       };
52413     } catch (Dali::DaliException e) {
52414       {
52415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52416       };
52417     } catch (...) {
52418       {
52419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52420       };
52421     }
52422   }
52423
52424   jresult = (void *)result;
52425   return jresult;
52426 }
52427
52428
52429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
52430   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52431
52432   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52433   {
52434     try {
52435       delete arg1;
52436     } catch (std::out_of_range& e) {
52437       {
52438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52439       };
52440     } catch (std::exception& e) {
52441       {
52442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52443       };
52444     } catch (Dali::DaliException e) {
52445       {
52446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52447       };
52448     } catch (...) {
52449       {
52450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52451       };
52452     }
52453   }
52454
52455 }
52456
52457
52458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
52459   unsigned int jresult ;
52460   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52461   bool result;
52462
52463   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52464   {
52465     try {
52466       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
52467     } catch (std::out_of_range& e) {
52468       {
52469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52470       };
52471     } catch (std::exception& e) {
52472       {
52473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52474       };
52475     } catch (Dali::DaliException e) {
52476       {
52477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52478       };
52479     } catch (...) {
52480       {
52481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52482       };
52483     }
52484   }
52485
52486   jresult = result;
52487   return jresult;
52488 }
52489
52490
52491 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
52492   unsigned long jresult ;
52493   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52494   std::size_t result;
52495
52496   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52497   {
52498     try {
52499       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
52500     } catch (std::out_of_range& e) {
52501       {
52502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52503       };
52504     } catch (std::exception& e) {
52505       {
52506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52507       };
52508     } catch (Dali::DaliException e) {
52509       {
52510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52511       };
52512     } catch (...) {
52513       {
52514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52515       };
52516     }
52517   }
52518
52519   jresult = (unsigned long)result;
52520   return jresult;
52521 }
52522
52523
52524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
52525   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52526   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52527
52528   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52529   arg2 = (void (*)(Dali::Actor))jarg2;
52530   {
52531     try {
52532       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
52533     } catch (std::out_of_range& e) {
52534       {
52535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52536       };
52537     } catch (std::exception& e) {
52538       {
52539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52540       };
52541     } catch (Dali::DaliException e) {
52542       {
52543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52544       };
52545     } catch (...) {
52546       {
52547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52548       };
52549     }
52550   }
52551
52552 }
52553
52554
52555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
52556   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52557   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52558
52559   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52560   arg2 = (void (*)(Dali::Actor))jarg2;
52561   {
52562     try {
52563       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
52564     } catch (std::out_of_range& e) {
52565       {
52566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52567       };
52568     } catch (std::exception& e) {
52569       {
52570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52571       };
52572     } catch (Dali::DaliException e) {
52573       {
52574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52575       };
52576     } catch (...) {
52577       {
52578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52579       };
52580     }
52581   }
52582
52583 }
52584
52585
52586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
52587   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52588   Dali::Actor arg2 ;
52589   Dali::Actor *argp2 ;
52590
52591   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52592   argp2 = (Dali::Actor *)jarg2;
52593   if (!argp2) {
52594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52595     return ;
52596   }
52597   arg2 = *argp2;
52598   {
52599     try {
52600       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
52601     } catch (std::out_of_range& e) {
52602       {
52603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52604       };
52605     } catch (std::exception& e) {
52606       {
52607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52608       };
52609     } catch (Dali::DaliException e) {
52610       {
52611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52612       };
52613     } catch (...) {
52614       {
52615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52616       };
52617     }
52618   }
52619
52620 }
52621
52622
52623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
52624   void * jresult ;
52625   Dali::Signal< void (Dali::Actor) > *result = 0 ;
52626
52627   {
52628     try {
52629       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
52630     } catch (std::out_of_range& e) {
52631       {
52632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52633       };
52634     } catch (std::exception& e) {
52635       {
52636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52637       };
52638     } catch (Dali::DaliException e) {
52639       {
52640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52641       };
52642     } catch (...) {
52643       {
52644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52645       };
52646     }
52647   }
52648
52649   jresult = (void *)result;
52650   return jresult;
52651 }
52652
52653
52654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
52655   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52656
52657   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52658   {
52659     try {
52660       delete arg1;
52661     } catch (std::out_of_range& e) {
52662       {
52663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52664       };
52665     } catch (std::exception& e) {
52666       {
52667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52668       };
52669     } catch (Dali::DaliException e) {
52670       {
52671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52672       };
52673     } catch (...) {
52674       {
52675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52676       };
52677     }
52678   }
52679
52680 }
52681
52682
52683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
52684   unsigned int jresult ;
52685   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52686   bool result;
52687
52688   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52689   {
52690     try {
52691       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52692     } catch (std::out_of_range& e) {
52693       {
52694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52695       };
52696     } catch (std::exception& e) {
52697       {
52698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52699       };
52700     } catch (Dali::DaliException e) {
52701       {
52702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52703       };
52704     } catch (...) {
52705       {
52706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52707       };
52708     }
52709   }
52710
52711   jresult = result;
52712   return jresult;
52713 }
52714
52715
52716 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
52717   unsigned long jresult ;
52718   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52719   std::size_t result;
52720
52721   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52722   {
52723     try {
52724       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52725     } catch (std::out_of_range& e) {
52726       {
52727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52728       };
52729     } catch (std::exception& e) {
52730       {
52731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52732       };
52733     } catch (Dali::DaliException e) {
52734       {
52735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52736       };
52737     } catch (...) {
52738       {
52739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52740       };
52741     }
52742   }
52743
52744   jresult = (unsigned long)result;
52745   return jresult;
52746 }
52747
52748
52749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
52750   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52751   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52752
52753   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52754   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52755   {
52756     try {
52757       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52758     } catch (std::out_of_range& e) {
52759       {
52760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52761       };
52762     } catch (std::exception& e) {
52763       {
52764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52765       };
52766     } catch (Dali::DaliException e) {
52767       {
52768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52769       };
52770     } catch (...) {
52771       {
52772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52773       };
52774     }
52775   }
52776
52777 }
52778
52779
52780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
52781   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52782   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52783
52784   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52785   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52786   {
52787     try {
52788       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52789     } catch (std::out_of_range& e) {
52790       {
52791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52792       };
52793     } catch (std::exception& e) {
52794       {
52795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52796       };
52797     } catch (Dali::DaliException e) {
52798       {
52799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52800       };
52801     } catch (...) {
52802       {
52803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52804       };
52805     }
52806   }
52807
52808 }
52809
52810
52811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
52812   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52813   Dali::KeyEvent *arg2 = 0 ;
52814
52815   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52816   arg2 = (Dali::KeyEvent *)jarg2;
52817   if (!arg2) {
52818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
52819     return ;
52820   }
52821   {
52822     try {
52823       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
52824     } catch (std::out_of_range& e) {
52825       {
52826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52827       };
52828     } catch (std::exception& e) {
52829       {
52830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52831       };
52832     } catch (Dali::DaliException e) {
52833       {
52834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52835       };
52836     } catch (...) {
52837       {
52838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52839       };
52840     }
52841   }
52842
52843 }
52844
52845
52846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
52847   void * jresult ;
52848   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
52849
52850   {
52851     try {
52852       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
52853     } catch (std::out_of_range& e) {
52854       {
52855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52856       };
52857     } catch (std::exception& e) {
52858       {
52859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52860       };
52861     } catch (Dali::DaliException e) {
52862       {
52863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52864       };
52865     } catch (...) {
52866       {
52867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52868       };
52869     }
52870   }
52871
52872   jresult = (void *)result;
52873   return jresult;
52874 }
52875
52876
52877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
52878   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52879
52880   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52881   {
52882     try {
52883       delete arg1;
52884     } catch (std::out_of_range& e) {
52885       {
52886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52887       };
52888     } catch (std::exception& e) {
52889       {
52890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52891       };
52892     } catch (Dali::DaliException e) {
52893       {
52894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52895       };
52896     } catch (...) {
52897       {
52898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52899       };
52900     }
52901   }
52902
52903 }
52904
52905
52906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
52907   unsigned int jresult ;
52908   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
52909   bool result;
52910
52911   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
52912   {
52913     try {
52914       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
52915     } catch (std::out_of_range& e) {
52916       {
52917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52918       };
52919     } catch (std::exception& e) {
52920       {
52921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52922       };
52923     } catch (Dali::DaliException e) {
52924       {
52925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52926       };
52927     } catch (...) {
52928       {
52929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52930       };
52931     }
52932   }
52933
52934   jresult = result;
52935   return jresult;
52936 }
52937
52938
52939 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
52940   unsigned long jresult ;
52941   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
52942   std::size_t result;
52943
52944   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
52945   {
52946     try {
52947       result = Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
52948     } catch (std::out_of_range& e) {
52949       {
52950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52951       };
52952     } catch (std::exception& e) {
52953       {
52954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52955       };
52956     } catch (Dali::DaliException e) {
52957       {
52958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52959       };
52960     } catch (...) {
52961       {
52962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52963       };
52964     }
52965   }
52966
52967   jresult = (unsigned long)result;
52968   return jresult;
52969 }
52970
52971
52972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
52973   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
52974   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
52975
52976   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
52977   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
52978   {
52979     try {
52980       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52981     } catch (std::out_of_range& e) {
52982       {
52983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52984       };
52985     } catch (std::exception& e) {
52986       {
52987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52988       };
52989     } catch (Dali::DaliException e) {
52990       {
52991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52992       };
52993     } catch (...) {
52994       {
52995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52996       };
52997     }
52998   }
52999
53000 }
53001
53002
53003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
53004   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53005   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
53006
53007   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53008   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
53009   {
53010     try {
53011       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53012     } catch (std::out_of_range& e) {
53013       {
53014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53015       };
53016     } catch (std::exception& e) {
53017       {
53018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53019       };
53020     } catch (Dali::DaliException e) {
53021       {
53022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53023       };
53024     } catch (...) {
53025       {
53026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53027       };
53028     }
53029   }
53030
53031 }
53032
53033
53034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
53035   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53036   Dali::TouchEvent *arg2 = 0 ;
53037
53038   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53039   arg2 = (Dali::TouchEvent *)jarg2;
53040   if (!arg2) {
53041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
53042     return ;
53043   }
53044   {
53045     try {
53046       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchEvent const &)*arg2);
53047     } catch (std::out_of_range& e) {
53048       {
53049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53050       };
53051     } catch (std::exception& e) {
53052       {
53053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53054       };
53055     } catch (Dali::DaliException e) {
53056       {
53057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53058       };
53059     } catch (...) {
53060       {
53061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53062       };
53063     }
53064   }
53065
53066 }
53067
53068
53069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
53070   void * jresult ;
53071   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
53072
53073   {
53074     try {
53075       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
53076     } catch (std::out_of_range& e) {
53077       {
53078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53079       };
53080     } catch (std::exception& e) {
53081       {
53082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53083       };
53084     } catch (Dali::DaliException e) {
53085       {
53086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53087       };
53088     } catch (...) {
53089       {
53090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53091       };
53092     }
53093   }
53094
53095   jresult = (void *)result;
53096   return jresult;
53097 }
53098
53099
53100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
53101   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53102
53103   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53104   {
53105     try {
53106       delete arg1;
53107     } catch (std::out_of_range& e) {
53108       {
53109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53110       };
53111     } catch (std::exception& e) {
53112       {
53113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53114       };
53115     } catch (Dali::DaliException e) {
53116       {
53117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53118       };
53119     } catch (...) {
53120       {
53121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53122       };
53123     }
53124   }
53125
53126 }
53127
53128
53129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
53130   unsigned int jresult ;
53131   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53132   bool result;
53133
53134   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53135   {
53136     try {
53137       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53138     } catch (std::out_of_range& e) {
53139       {
53140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53141       };
53142     } catch (std::exception& e) {
53143       {
53144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53145       };
53146     } catch (Dali::DaliException e) {
53147       {
53148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53149       };
53150     } catch (...) {
53151       {
53152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53153       };
53154     }
53155   }
53156
53157   jresult = result;
53158   return jresult;
53159 }
53160
53161
53162 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
53163   unsigned long jresult ;
53164   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53165   std::size_t result;
53166
53167   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53168   {
53169     try {
53170       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53171     } catch (std::out_of_range& e) {
53172       {
53173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53174       };
53175     } catch (std::exception& e) {
53176       {
53177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53178       };
53179     } catch (Dali::DaliException e) {
53180       {
53181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53182       };
53183     } catch (...) {
53184       {
53185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53186       };
53187     }
53188   }
53189
53190   jresult = (unsigned long)result;
53191   return jresult;
53192 }
53193
53194
53195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
53196   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53197   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53198
53199   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53200   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53201   {
53202     try {
53203       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53204     } catch (std::out_of_range& e) {
53205       {
53206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53207       };
53208     } catch (std::exception& e) {
53209       {
53210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53211       };
53212     } catch (Dali::DaliException e) {
53213       {
53214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53215       };
53216     } catch (...) {
53217       {
53218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53219       };
53220     }
53221   }
53222
53223 }
53224
53225
53226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
53227   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53228   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53229
53230   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53231   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53232   {
53233     try {
53234       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53235     } catch (std::out_of_range& e) {
53236       {
53237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53238       };
53239     } catch (std::exception& e) {
53240       {
53241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53242       };
53243     } catch (Dali::DaliException e) {
53244       {
53245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53246       };
53247     } catch (...) {
53248       {
53249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53250       };
53251     }
53252   }
53253
53254 }
53255
53256
53257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
53258   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53259   Dali::WheelEvent *arg2 = 0 ;
53260
53261   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53262   arg2 = (Dali::WheelEvent *)jarg2;
53263   if (!arg2) {
53264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
53265     return ;
53266   }
53267   {
53268     try {
53269       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
53270     } catch (std::out_of_range& e) {
53271       {
53272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53273       };
53274     } catch (std::exception& e) {
53275       {
53276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53277       };
53278     } catch (Dali::DaliException e) {
53279       {
53280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53281       };
53282     } catch (...) {
53283       {
53284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53285       };
53286     }
53287   }
53288
53289 }
53290
53291
53292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
53293   void * jresult ;
53294   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
53295
53296   {
53297     try {
53298       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
53299     } catch (std::out_of_range& e) {
53300       {
53301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53302       };
53303     } catch (std::exception& e) {
53304       {
53305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53306       };
53307     } catch (Dali::DaliException e) {
53308       {
53309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53310       };
53311     } catch (...) {
53312       {
53313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53314       };
53315     }
53316   }
53317
53318   jresult = (void *)result;
53319   return jresult;
53320 }
53321
53322
53323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
53324   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53325
53326   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53327   {
53328     try {
53329       delete arg1;
53330     } catch (std::out_of_range& e) {
53331       {
53332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53333       };
53334     } catch (std::exception& e) {
53335       {
53336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53337       };
53338     } catch (Dali::DaliException e) {
53339       {
53340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53341       };
53342     } catch (...) {
53343       {
53344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53345       };
53346     }
53347   }
53348
53349 }
53350
53351
53352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
53353   void * jresult ;
53354   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53355
53356   {
53357     try {
53358       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
53359     } catch (std::out_of_range& e) {
53360       {
53361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53362       };
53363     } catch (std::exception& e) {
53364       {
53365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53366       };
53367     } catch (Dali::DaliException e) {
53368       {
53369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53370       };
53371     } catch (...) {
53372       {
53373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53374       };
53375     }
53376   }
53377
53378   jresult = (void *)result;
53379   return jresult;
53380 }
53381
53382
53383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
53384   void * jresult ;
53385   Dali::Radian arg1 ;
53386   Dali::Radian arg2 ;
53387   Dali::Radian *argp1 ;
53388   Dali::Radian *argp2 ;
53389   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53390
53391   argp1 = (Dali::Radian *)jarg1;
53392   if (!argp1) {
53393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53394     return 0;
53395   }
53396   arg1 = *argp1;
53397   argp2 = (Dali::Radian *)jarg2;
53398   if (!argp2) {
53399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53400     return 0;
53401   }
53402   arg2 = *argp2;
53403   {
53404     try {
53405       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
53406     } catch (std::out_of_range& e) {
53407       {
53408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53409       };
53410     } catch (std::exception& e) {
53411       {
53412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53413       };
53414     } catch (Dali::DaliException e) {
53415       {
53416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53417       };
53418     } catch (...) {
53419       {
53420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53421       };
53422     }
53423   }
53424
53425   jresult = (void *)result;
53426   return jresult;
53427 }
53428
53429
53430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
53431   void * jresult ;
53432   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
53433   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53434
53435   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53436   if (!arg1) {
53437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
53438     return 0;
53439   }
53440   {
53441     try {
53442       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
53443     } catch (std::out_of_range& e) {
53444       {
53445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53446       };
53447     } catch (std::exception& e) {
53448       {
53449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53450       };
53451     } catch (Dali::DaliException e) {
53452       {
53453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53454       };
53455     } catch (...) {
53456       {
53457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53458       };
53459     }
53460   }
53461
53462   jresult = (void *)result;
53463   return jresult;
53464 }
53465
53466
53467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
53468   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53469   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53470
53471   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53472   arg2 = (Dali::Radian *)jarg2;
53473   if (arg1) (arg1)->first = *arg2;
53474 }
53475
53476
53477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
53478   void * jresult ;
53479   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53480   Dali::Radian *result = 0 ;
53481
53482   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53483   result = (Dali::Radian *)& ((arg1)->first);
53484   jresult = (void *)result;
53485   return jresult;
53486 }
53487
53488
53489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
53490   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53491   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53492
53493   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53494   arg2 = (Dali::Radian *)jarg2;
53495   if (arg1) (arg1)->second = *arg2;
53496 }
53497
53498
53499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
53500   void * jresult ;
53501   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53502   Dali::Radian *result = 0 ;
53503
53504   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53505   result = (Dali::Radian *)& ((arg1)->second);
53506   jresult = (void *)result;
53507   return jresult;
53508 }
53509
53510
53511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
53512   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53513
53514   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53515   {
53516     try {
53517       delete arg1;
53518     } catch (std::out_of_range& e) {
53519       {
53520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53521       };
53522     } catch (std::exception& e) {
53523       {
53524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53525       };
53526     } catch (Dali::DaliException e) {
53527       {
53528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53529       };
53530     } catch (...) {
53531       {
53532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53533       };
53534     }
53535   }
53536
53537 }
53538
53539
53540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
53541   unsigned int jresult ;
53542   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53543   bool result;
53544
53545   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53546   {
53547     try {
53548       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);
53549     } catch (std::out_of_range& e) {
53550       {
53551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53552       };
53553     } catch (std::exception& e) {
53554       {
53555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53556       };
53557     } catch (Dali::DaliException e) {
53558       {
53559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53560       };
53561     } catch (...) {
53562       {
53563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53564       };
53565     }
53566   }
53567
53568   jresult = result;
53569   return jresult;
53570 }
53571
53572
53573 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53574   unsigned long jresult ;
53575   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53576   std::size_t result;
53577
53578   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53579   {
53580     try {
53581       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);
53582     } catch (std::out_of_range& e) {
53583       {
53584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53585       };
53586     } catch (std::exception& e) {
53587       {
53588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53589       };
53590     } catch (Dali::DaliException e) {
53591       {
53592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53593       };
53594     } catch (...) {
53595       {
53596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53597       };
53598     }
53599   }
53600
53601   jresult = (unsigned long)result;
53602   return jresult;
53603 }
53604
53605
53606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53607   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53608   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53609
53610   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53611   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53612   {
53613     try {
53614       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53615     } catch (std::out_of_range& e) {
53616       {
53617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53618       };
53619     } catch (std::exception& e) {
53620       {
53621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53622       };
53623     } catch (Dali::DaliException e) {
53624       {
53625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53626       };
53627     } catch (...) {
53628       {
53629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53630       };
53631     }
53632   }
53633
53634 }
53635
53636
53637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53638   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53639   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53640
53641   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53642   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53643   {
53644     try {
53645       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53646     } catch (std::out_of_range& e) {
53647       {
53648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53649       };
53650     } catch (std::exception& e) {
53651       {
53652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53653       };
53654     } catch (Dali::DaliException e) {
53655       {
53656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53657       };
53658     } catch (...) {
53659       {
53660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53661       };
53662     }
53663   }
53664
53665 }
53666
53667
53668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53669   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53670   Dali::Actor arg2 ;
53671   Dali::PanGesture *arg3 = 0 ;
53672   Dali::Actor *argp2 ;
53673
53674   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53675   argp2 = (Dali::Actor *)jarg2;
53676   if (!argp2) {
53677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53678     return ;
53679   }
53680   arg2 = *argp2;
53681   arg3 = (Dali::PanGesture *)jarg3;
53682   if (!arg3) {
53683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
53684     return ;
53685   }
53686   {
53687     try {
53688       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
53689     } catch (std::out_of_range& e) {
53690       {
53691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53692       };
53693     } catch (std::exception& e) {
53694       {
53695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53696       };
53697     } catch (Dali::DaliException e) {
53698       {
53699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53700       };
53701     } catch (...) {
53702       {
53703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53704       };
53705     }
53706   }
53707
53708 }
53709
53710
53711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
53712   void * jresult ;
53713   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
53714
53715   {
53716     try {
53717       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
53718     } catch (std::out_of_range& e) {
53719       {
53720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53721       };
53722     } catch (std::exception& e) {
53723       {
53724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53725       };
53726     } catch (Dali::DaliException e) {
53727       {
53728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53729       };
53730     } catch (...) {
53731       {
53732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53733       };
53734     }
53735   }
53736
53737   jresult = (void *)result;
53738   return jresult;
53739 }
53740
53741
53742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
53743   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53744
53745   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53746   {
53747     try {
53748       delete arg1;
53749     } catch (std::out_of_range& e) {
53750       {
53751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53752       };
53753     } catch (std::exception& e) {
53754       {
53755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53756       };
53757     } catch (Dali::DaliException e) {
53758       {
53759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53760       };
53761     } catch (...) {
53762       {
53763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53764       };
53765     }
53766   }
53767
53768 }
53769
53770
53771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
53772   unsigned int jresult ;
53773   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53774   bool result;
53775
53776   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53777   {
53778     try {
53779       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);
53780     } catch (std::out_of_range& e) {
53781       {
53782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53783       };
53784     } catch (std::exception& e) {
53785       {
53786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53787       };
53788     } catch (Dali::DaliException e) {
53789       {
53790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53791       };
53792     } catch (...) {
53793       {
53794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53795       };
53796     }
53797   }
53798
53799   jresult = result;
53800   return jresult;
53801 }
53802
53803
53804 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53805   unsigned long jresult ;
53806   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53807   std::size_t result;
53808
53809   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53810   {
53811     try {
53812       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);
53813     } catch (std::out_of_range& e) {
53814       {
53815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53816       };
53817     } catch (std::exception& e) {
53818       {
53819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53820       };
53821     } catch (Dali::DaliException e) {
53822       {
53823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53824       };
53825     } catch (...) {
53826       {
53827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53828       };
53829     }
53830   }
53831
53832   jresult = (unsigned long)result;
53833   return jresult;
53834 }
53835
53836
53837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53838   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53839   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53840
53841   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53842   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53843   {
53844     try {
53845       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53846     } catch (std::out_of_range& e) {
53847       {
53848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53849       };
53850     } catch (std::exception& e) {
53851       {
53852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53853       };
53854     } catch (Dali::DaliException e) {
53855       {
53856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53857       };
53858     } catch (...) {
53859       {
53860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53861       };
53862     }
53863   }
53864
53865 }
53866
53867
53868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53869   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53870   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53871
53872   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53873   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53874   {
53875     try {
53876       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53877     } catch (std::out_of_range& e) {
53878       {
53879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53880       };
53881     } catch (std::exception& e) {
53882       {
53883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53884       };
53885     } catch (Dali::DaliException e) {
53886       {
53887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53888       };
53889     } catch (...) {
53890       {
53891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53892       };
53893     }
53894   }
53895
53896 }
53897
53898
53899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53900   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53901   Dali::Actor arg2 ;
53902   Dali::PinchGesture *arg3 = 0 ;
53903   Dali::Actor *argp2 ;
53904
53905   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53906   argp2 = (Dali::Actor *)jarg2;
53907   if (!argp2) {
53908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53909     return ;
53910   }
53911   arg2 = *argp2;
53912   arg3 = (Dali::PinchGesture *)jarg3;
53913   if (!arg3) {
53914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
53915     return ;
53916   }
53917   {
53918     try {
53919       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
53920     } catch (std::out_of_range& e) {
53921       {
53922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53923       };
53924     } catch (std::exception& e) {
53925       {
53926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53927       };
53928     } catch (Dali::DaliException e) {
53929       {
53930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53931       };
53932     } catch (...) {
53933       {
53934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53935       };
53936     }
53937   }
53938
53939 }
53940
53941
53942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
53943   void * jresult ;
53944   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
53945
53946   {
53947     try {
53948       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
53949     } catch (std::out_of_range& e) {
53950       {
53951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53952       };
53953     } catch (std::exception& e) {
53954       {
53955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53956       };
53957     } catch (Dali::DaliException e) {
53958       {
53959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53960       };
53961     } catch (...) {
53962       {
53963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53964       };
53965     }
53966   }
53967
53968   jresult = (void *)result;
53969   return jresult;
53970 }
53971
53972
53973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
53974   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53975
53976   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53977   {
53978     try {
53979       delete arg1;
53980     } catch (std::out_of_range& e) {
53981       {
53982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53983       };
53984     } catch (std::exception& e) {
53985       {
53986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53987       };
53988     } catch (Dali::DaliException e) {
53989       {
53990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53991       };
53992     } catch (...) {
53993       {
53994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53995       };
53996     }
53997   }
53998
53999 }
54000
54001
54002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
54003   unsigned int jresult ;
54004   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54005   bool result;
54006
54007   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54008   {
54009     try {
54010       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);
54011     } catch (std::out_of_range& e) {
54012       {
54013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54014       };
54015     } catch (std::exception& e) {
54016       {
54017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54018       };
54019     } catch (Dali::DaliException e) {
54020       {
54021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54022       };
54023     } catch (...) {
54024       {
54025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54026       };
54027     }
54028   }
54029
54030   jresult = result;
54031   return jresult;
54032 }
54033
54034
54035 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54036   unsigned long jresult ;
54037   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54038   std::size_t result;
54039
54040   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54041   {
54042     try {
54043       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);
54044     } catch (std::out_of_range& e) {
54045       {
54046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54047       };
54048     } catch (std::exception& e) {
54049       {
54050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54051       };
54052     } catch (Dali::DaliException e) {
54053       {
54054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54055       };
54056     } catch (...) {
54057       {
54058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54059       };
54060     }
54061   }
54062
54063   jresult = (unsigned long)result;
54064   return jresult;
54065 }
54066
54067
54068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54069   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54070   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54071
54072   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54073   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54074   {
54075     try {
54076       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54077     } catch (std::out_of_range& e) {
54078       {
54079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54080       };
54081     } catch (std::exception& e) {
54082       {
54083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54084       };
54085     } catch (Dali::DaliException e) {
54086       {
54087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54088       };
54089     } catch (...) {
54090       {
54091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54092       };
54093     }
54094   }
54095
54096 }
54097
54098
54099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54100   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54101   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54102
54103   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54104   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54105   {
54106     try {
54107       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54108     } catch (std::out_of_range& e) {
54109       {
54110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54111       };
54112     } catch (std::exception& e) {
54113       {
54114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54115       };
54116     } catch (Dali::DaliException e) {
54117       {
54118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54119       };
54120     } catch (...) {
54121       {
54122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54123       };
54124     }
54125   }
54126
54127 }
54128
54129
54130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54131   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54132   Dali::Actor arg2 ;
54133   Dali::TapGesture *arg3 = 0 ;
54134   Dali::Actor *argp2 ;
54135
54136   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54137   argp2 = (Dali::Actor *)jarg2;
54138   if (!argp2) {
54139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54140     return ;
54141   }
54142   arg2 = *argp2;
54143   arg3 = (Dali::TapGesture *)jarg3;
54144   if (!arg3) {
54145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
54146     return ;
54147   }
54148   {
54149     try {
54150       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
54151     } catch (std::out_of_range& e) {
54152       {
54153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54154       };
54155     } catch (std::exception& e) {
54156       {
54157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54158       };
54159     } catch (Dali::DaliException e) {
54160       {
54161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54162       };
54163     } catch (...) {
54164       {
54165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54166       };
54167     }
54168   }
54169
54170 }
54171
54172
54173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
54174   void * jresult ;
54175   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
54176
54177   {
54178     try {
54179       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
54180     } catch (std::out_of_range& e) {
54181       {
54182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54183       };
54184     } catch (std::exception& e) {
54185       {
54186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54187       };
54188     } catch (Dali::DaliException e) {
54189       {
54190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54191       };
54192     } catch (...) {
54193       {
54194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54195       };
54196     }
54197   }
54198
54199   jresult = (void *)result;
54200   return jresult;
54201 }
54202
54203
54204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
54205   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54206
54207   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54208   {
54209     try {
54210       delete arg1;
54211     } catch (std::out_of_range& e) {
54212       {
54213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54214       };
54215     } catch (std::exception& e) {
54216       {
54217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54218       };
54219     } catch (Dali::DaliException e) {
54220       {
54221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54222       };
54223     } catch (...) {
54224       {
54225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54226       };
54227     }
54228   }
54229
54230 }
54231
54232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
54233   unsigned int jresult ;
54234   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54235   bool result = false;
54236
54237   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54238   {
54239     try {
54240       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);
54241     } catch (std::out_of_range& e) {
54242       {
54243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54244       };
54245     } catch (std::exception& e) {
54246       {
54247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54248       };
54249     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54250   }
54251   jresult = result;
54252   return jresult;
54253 }
54254
54255 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
54256   unsigned long jresult ;
54257   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54258   std::size_t result = 0;
54259
54260   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54261   {
54262     try {
54263       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);
54264     } catch (std::out_of_range& e) {
54265       {
54266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54267       };
54268     } catch (std::exception& e) {
54269       {
54270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54271       };
54272     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54273   }
54274   jresult = (unsigned long)result;
54275   return jresult;
54276 }
54277
54278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
54279   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54280   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54281
54282   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54283   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54284   {
54285     try {
54286       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
54287     } catch (std::out_of_range& e) {
54288       {
54289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54290       };
54291     } catch (std::exception& e) {
54292       {
54293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54294       };
54295     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54296   }
54297 }
54298
54299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
54300   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54301   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54302
54303   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54304   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54305   {
54306     try {
54307       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
54308     } catch (std::out_of_range& e) {
54309       {
54310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54311       };
54312     } catch (std::exception& e) {
54313       {
54314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54315       };
54316     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54317   }
54318 }
54319
54320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
54321   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54322   Dali::Actor arg2 ;
54323   //bool arg3 ;
54324   Dali::LayoutDirection::Type arg4 ;
54325   Dali::Actor *argp2 ;
54326
54327   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54328   argp2 = (Dali::Actor *)jarg2;
54329   if (!argp2) {
54330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54331     return ;
54332   }
54333   arg2 = *argp2;
54334   //arg3 = jarg3 ? true : false;
54335   arg4 = (Dali::LayoutDirection::Type)jarg4;
54336   {
54337     try {
54338       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
54339     } catch (std::out_of_range& e) {
54340       {
54341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54342       };
54343     } catch (std::exception& e) {
54344       {
54345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54346       };
54347     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54348   }
54349 }
54350
54351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
54352   void * jresult ;
54353   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
54354
54355   {
54356     try {
54357       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
54358     } catch (std::out_of_range& e) {
54359       {
54360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54361       };
54362     } catch (std::exception& e) {
54363       {
54364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54365       };
54366     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54367   }
54368   jresult = (void *)result;
54369   return jresult;
54370 }
54371
54372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
54373   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54374
54375   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54376   {
54377     try {
54378       delete arg1;
54379     } catch (std::out_of_range& e) {
54380       {
54381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54382       };
54383     } catch (std::exception& e) {
54384       {
54385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54386       };
54387     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54388   }
54389 }
54390
54391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
54392   unsigned int jresult ;
54393   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54394   bool result;
54395
54396   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54397   {
54398     try {
54399       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);
54400     } catch (std::out_of_range& e) {
54401       {
54402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54403       };
54404     } catch (std::exception& e) {
54405       {
54406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54407       };
54408     } catch (Dali::DaliException e) {
54409       {
54410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54411       };
54412     } catch (...) {
54413       {
54414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54415       };
54416     }
54417   }
54418
54419   jresult = result;
54420   return jresult;
54421 }
54422
54423
54424 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
54425   unsigned long jresult ;
54426   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54427   std::size_t result;
54428
54429   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54430   {
54431     try {
54432       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);
54433     } catch (std::out_of_range& e) {
54434       {
54435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54436       };
54437     } catch (std::exception& e) {
54438       {
54439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54440       };
54441     } catch (Dali::DaliException e) {
54442       {
54443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54444       };
54445     } catch (...) {
54446       {
54447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54448       };
54449     }
54450   }
54451
54452   jresult = (unsigned long)result;
54453   return jresult;
54454 }
54455
54456
54457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
54458   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54459   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54460
54461   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54462   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54463   {
54464     try {
54465       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
54466     } catch (std::out_of_range& e) {
54467       {
54468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54469       };
54470     } catch (std::exception& e) {
54471       {
54472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54473       };
54474     } catch (Dali::DaliException e) {
54475       {
54476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54477       };
54478     } catch (...) {
54479       {
54480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54481       };
54482     }
54483   }
54484
54485 }
54486
54487
54488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54489   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54490   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54491
54492   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54493   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54494   {
54495     try {
54496       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
54497     } catch (std::out_of_range& e) {
54498       {
54499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54500       };
54501     } catch (std::exception& e) {
54502       {
54503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54504       };
54505     } catch (Dali::DaliException e) {
54506       {
54507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54508       };
54509     } catch (...) {
54510       {
54511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54512       };
54513     }
54514   }
54515
54516 }
54517
54518
54519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
54520   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54521   Dali::Actor arg2 ;
54522   bool arg3 ;
54523   Dali::DevelActor::VisibilityChange::Type arg4 ;
54524   Dali::Actor *argp2 ;
54525
54526   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54527   argp2 = (Dali::Actor *)jarg2;
54528   if (!argp2) {
54529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54530     return ;
54531   }
54532   arg2 = *argp2;
54533   arg3 = jarg3 ? true : false;
54534   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
54535   {
54536     try {
54537       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54538     } catch (std::out_of_range& e) {
54539       {
54540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54541       };
54542     } catch (std::exception& e) {
54543       {
54544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54545       };
54546     } catch (Dali::DaliException e) {
54547       {
54548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54549       };
54550     } catch (...) {
54551       {
54552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54553       };
54554     }
54555   }
54556
54557 }
54558
54559
54560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
54561   void * jresult ;
54562   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
54563
54564   {
54565     try {
54566       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
54567     } catch (std::out_of_range& e) {
54568       {
54569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54570       };
54571     } catch (std::exception& e) {
54572       {
54573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54574       };
54575     } catch (Dali::DaliException e) {
54576       {
54577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54578       };
54579     } catch (...) {
54580       {
54581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54582       };
54583     }
54584   }
54585
54586   jresult = (void *)result;
54587   return jresult;
54588 }
54589
54590
54591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
54592   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54593
54594   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54595   {
54596     try {
54597       delete arg1;
54598     } catch (std::out_of_range& e) {
54599       {
54600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54601       };
54602     } catch (std::exception& e) {
54603       {
54604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54605       };
54606     } catch (Dali::DaliException e) {
54607       {
54608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54609       };
54610     } catch (...) {
54611       {
54612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54613       };
54614     }
54615   }
54616
54617 }
54618
54619
54620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
54621   void * jresult ;
54622   Dali::Timer *result = 0 ;
54623
54624   {
54625     try {
54626       result = (Dali::Timer *)new Dali::Timer();
54627     } catch (std::out_of_range& e) {
54628       {
54629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54630       };
54631     } catch (std::exception& e) {
54632       {
54633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54634       };
54635     } catch (Dali::DaliException e) {
54636       {
54637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54638       };
54639     } catch (...) {
54640       {
54641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54642       };
54643     }
54644   }
54645
54646   jresult = (void *)result;
54647   return jresult;
54648 }
54649
54650
54651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
54652   void * jresult ;
54653   unsigned int arg1 ;
54654   Dali::Timer result;
54655
54656   arg1 = (unsigned int)jarg1;
54657   {
54658     try {
54659       result = Dali::Timer::New(arg1);
54660     } catch (std::out_of_range& e) {
54661       {
54662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54663       };
54664     } catch (std::exception& e) {
54665       {
54666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54667       };
54668     } catch (Dali::DaliException e) {
54669       {
54670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54671       };
54672     } catch (...) {
54673       {
54674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54675       };
54676     }
54677   }
54678
54679   jresult = new Dali::Timer((const Dali::Timer &)result);
54680   return jresult;
54681 }
54682
54683
54684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
54685   void * jresult ;
54686   Dali::Timer *arg1 = 0 ;
54687   Dali::Timer *result = 0 ;
54688
54689   arg1 = (Dali::Timer *)jarg1;
54690   if (!arg1) {
54691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54692     return 0;
54693   }
54694   {
54695     try {
54696       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
54697     } catch (std::out_of_range& e) {
54698       {
54699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54700       };
54701     } catch (std::exception& e) {
54702       {
54703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54704       };
54705     } catch (Dali::DaliException e) {
54706       {
54707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54708       };
54709     } catch (...) {
54710       {
54711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54712       };
54713     }
54714   }
54715
54716   jresult = (void *)result;
54717   return jresult;
54718 }
54719
54720
54721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
54722   void * jresult ;
54723   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54724   Dali::Timer *arg2 = 0 ;
54725   Dali::Timer *result = 0 ;
54726
54727   arg1 = (Dali::Timer *)jarg1;
54728   arg2 = (Dali::Timer *)jarg2;
54729   if (!arg2) {
54730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54731     return 0;
54732   }
54733   {
54734     try {
54735       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
54736     } catch (std::out_of_range& e) {
54737       {
54738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54739       };
54740     } catch (std::exception& e) {
54741       {
54742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54743       };
54744     } catch (Dali::DaliException e) {
54745       {
54746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54747       };
54748     } catch (...) {
54749       {
54750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54751       };
54752     }
54753   }
54754
54755   jresult = (void *)result;
54756   return jresult;
54757 }
54758
54759
54760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
54761   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54762
54763   arg1 = (Dali::Timer *)jarg1;
54764   {
54765     try {
54766       delete arg1;
54767     } catch (std::out_of_range& e) {
54768       {
54769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54770       };
54771     } catch (std::exception& e) {
54772       {
54773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54774       };
54775     } catch (Dali::DaliException e) {
54776       {
54777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54778       };
54779     } catch (...) {
54780       {
54781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54782       };
54783     }
54784   }
54785
54786 }
54787
54788
54789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
54790   void * jresult ;
54791   Dali::BaseHandle arg1 ;
54792   Dali::BaseHandle *argp1 ;
54793   Dali::Timer result;
54794
54795   argp1 = (Dali::BaseHandle *)jarg1;
54796   if (!argp1) {
54797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54798     return 0;
54799   }
54800   arg1 = *argp1;
54801   {
54802     try {
54803       result = Dali::Timer::DownCast(arg1);
54804     } catch (std::out_of_range& e) {
54805       {
54806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54807       };
54808     } catch (std::exception& e) {
54809       {
54810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54811       };
54812     } catch (Dali::DaliException e) {
54813       {
54814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54815       };
54816     } catch (...) {
54817       {
54818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54819       };
54820     }
54821   }
54822
54823   jresult = new Dali::Timer((const Dali::Timer &)result);
54824   return jresult;
54825 }
54826
54827
54828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
54829   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54830
54831   arg1 = (Dali::Timer *)jarg1;
54832   {
54833     try {
54834       (arg1)->Start();
54835     } catch (std::out_of_range& e) {
54836       {
54837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54838       };
54839     } catch (std::exception& e) {
54840       {
54841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54842       };
54843     } catch (Dali::DaliException e) {
54844       {
54845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54846       };
54847     } catch (...) {
54848       {
54849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54850       };
54851     }
54852   }
54853
54854 }
54855
54856
54857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
54858   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54859
54860   arg1 = (Dali::Timer *)jarg1;
54861   {
54862     try {
54863       (arg1)->Stop();
54864     } catch (std::out_of_range& e) {
54865       {
54866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54867       };
54868     } catch (std::exception& e) {
54869       {
54870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54871       };
54872     } catch (Dali::DaliException e) {
54873       {
54874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54875       };
54876     } catch (...) {
54877       {
54878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54879       };
54880     }
54881   }
54882
54883 }
54884
54885
54886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
54887   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54888   unsigned int arg2 ;
54889
54890   arg1 = (Dali::Timer *)jarg1;
54891   arg2 = (unsigned int)jarg2;
54892   {
54893     try {
54894       (arg1)->SetInterval(arg2);
54895     } catch (std::out_of_range& e) {
54896       {
54897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54898       };
54899     } catch (std::exception& e) {
54900       {
54901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54902       };
54903     } catch (Dali::DaliException e) {
54904       {
54905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54906       };
54907     } catch (...) {
54908       {
54909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54910       };
54911     }
54912   }
54913
54914 }
54915
54916
54917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
54918   unsigned int jresult ;
54919   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54920   unsigned int result;
54921
54922   arg1 = (Dali::Timer *)jarg1;
54923   {
54924     try {
54925       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
54926     } catch (std::out_of_range& e) {
54927       {
54928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54929       };
54930     } catch (std::exception& e) {
54931       {
54932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54933       };
54934     } catch (Dali::DaliException e) {
54935       {
54936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54937       };
54938     } catch (...) {
54939       {
54940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54941       };
54942     }
54943   }
54944
54945   jresult = result;
54946   return jresult;
54947 }
54948
54949
54950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
54951   unsigned int jresult ;
54952   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54953   bool result;
54954
54955   arg1 = (Dali::Timer *)jarg1;
54956   {
54957     try {
54958       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
54959     } catch (std::out_of_range& e) {
54960       {
54961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54962       };
54963     } catch (std::exception& e) {
54964       {
54965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54966       };
54967     } catch (Dali::DaliException e) {
54968       {
54969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54970       };
54971     } catch (...) {
54972       {
54973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54974       };
54975     }
54976   }
54977
54978   jresult = result;
54979   return jresult;
54980 }
54981
54982
54983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
54984   void * jresult ;
54985   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54986   Dali::Timer::TimerSignalType *result = 0 ;
54987
54988   arg1 = (Dali::Timer *)jarg1;
54989   {
54990     try {
54991       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
54992     } catch (std::out_of_range& e) {
54993       {
54994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54995       };
54996     } catch (std::exception& e) {
54997       {
54998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54999       };
55000     } catch (Dali::DaliException e) {
55001       {
55002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55003       };
55004     } catch (...) {
55005       {
55006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55007       };
55008     }
55009   }
55010
55011   jresult = (void *)result;
55012   return jresult;
55013 }
55014
55015
55016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55017   unsigned int jresult ;
55018   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55019   bool result;
55020
55021   arg1 = (Dali::Signal< bool () > *)jarg1;
55022   {
55023     try {
55024       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
55025     } catch (std::out_of_range& e) {
55026       {
55027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55028       };
55029     } catch (std::exception& e) {
55030       {
55031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55032       };
55033     } catch (Dali::DaliException e) {
55034       {
55035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55036       };
55037     } catch (...) {
55038       {
55039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55040       };
55041     }
55042   }
55043
55044   jresult = result;
55045   return jresult;
55046 }
55047
55048
55049 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55050   unsigned long jresult ;
55051   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55052   std::size_t result;
55053
55054   arg1 = (Dali::Signal< bool () > *)jarg1;
55055   {
55056     try {
55057       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
55058     } catch (std::out_of_range& e) {
55059       {
55060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55061       };
55062     } catch (std::exception& e) {
55063       {
55064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55065       };
55066     } catch (Dali::DaliException e) {
55067       {
55068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55069       };
55070     } catch (...) {
55071       {
55072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55073       };
55074     }
55075   }
55076
55077   jresult = (unsigned long)result;
55078   return jresult;
55079 }
55080
55081
55082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
55083   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55084   bool (*arg2)() = (bool (*)()) 0 ;
55085
55086   arg1 = (Dali::Signal< bool () > *)jarg1;
55087   arg2 = (bool (*)())jarg2;
55088   {
55089     try {
55090       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
55091     } catch (std::out_of_range& e) {
55092       {
55093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55094       };
55095     } catch (std::exception& e) {
55096       {
55097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55098       };
55099     } catch (Dali::DaliException e) {
55100       {
55101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55102       };
55103     } catch (...) {
55104       {
55105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55106       };
55107     }
55108   }
55109
55110 }
55111
55112
55113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55114   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55115   bool (*arg2)() = (bool (*)()) 0 ;
55116
55117   arg1 = (Dali::Signal< bool () > *)jarg1;
55118   arg2 = (bool (*)())jarg2;
55119   {
55120     try {
55121       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55122     } catch (std::out_of_range& e) {
55123       {
55124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55125       };
55126     } catch (std::exception& e) {
55127       {
55128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55129       };
55130     } catch (Dali::DaliException e) {
55131       {
55132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55133       };
55134     } catch (...) {
55135       {
55136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55137       };
55138     }
55139   }
55140
55141 }
55142
55143
55144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55145   unsigned int jresult ;
55146   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55147   bool result;
55148
55149   arg1 = (Dali::Signal< bool () > *)jarg1;
55150   {
55151     try {
55152       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55153     } catch (std::out_of_range& e) {
55154       {
55155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55156       };
55157     } catch (std::exception& e) {
55158       {
55159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55160       };
55161     } catch (Dali::DaliException e) {
55162       {
55163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55164       };
55165     } catch (...) {
55166       {
55167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55168       };
55169     }
55170   }
55171
55172   jresult = result;
55173   return jresult;
55174 }
55175
55176
55177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55178   void * jresult ;
55179   Dali::Signal< bool () > *result = 0 ;
55180
55181   {
55182     try {
55183       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55184     } catch (std::out_of_range& e) {
55185       {
55186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55187       };
55188     } catch (std::exception& e) {
55189       {
55190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55191       };
55192     } catch (Dali::DaliException e) {
55193       {
55194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55195       };
55196     } catch (...) {
55197       {
55198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55199       };
55200     }
55201   }
55202
55203   jresult = (void *)result;
55204   return jresult;
55205 }
55206
55207
55208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55209   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55210
55211   arg1 = (Dali::Signal< bool () > *)jarg1;
55212   {
55213     try {
55214       delete arg1;
55215     } catch (std::out_of_range& e) {
55216       {
55217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55218       };
55219     } catch (std::exception& e) {
55220       {
55221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55222       };
55223     } catch (Dali::DaliException e) {
55224       {
55225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55226       };
55227     } catch (...) {
55228       {
55229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55230       };
55231     }
55232   }
55233
55234 }
55235
55236
55237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55238   int jresult ;
55239   int result;
55240
55241   {
55242     try {
55243       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55244     } catch (std::out_of_range& e) {
55245       {
55246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55247       };
55248     } catch (std::exception& e) {
55249       {
55250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55251       };
55252     } catch (Dali::DaliException e) {
55253       {
55254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55255       };
55256     } catch (...) {
55257       {
55258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55259       };
55260     }
55261   }
55262
55263   jresult = (int)result;
55264   return jresult;
55265 }
55266
55267
55268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55269   int jresult ;
55270   int result;
55271
55272   {
55273     try {
55274       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55275     } catch (std::out_of_range& e) {
55276       {
55277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55278       };
55279     } catch (std::exception& e) {
55280       {
55281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55282       };
55283     } catch (Dali::DaliException e) {
55284       {
55285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55286       };
55287     } catch (...) {
55288       {
55289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55290       };
55291     }
55292   }
55293
55294   jresult = (int)result;
55295   return jresult;
55296 }
55297
55298
55299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55300   int jresult ;
55301   int result;
55302
55303   {
55304     try {
55305       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55306     } catch (std::out_of_range& e) {
55307       {
55308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55309       };
55310     } catch (std::exception& e) {
55311       {
55312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55313       };
55314     } catch (Dali::DaliException e) {
55315       {
55316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55317       };
55318     } catch (...) {
55319       {
55320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55321       };
55322     }
55323   }
55324
55325   jresult = (int)result;
55326   return jresult;
55327 }
55328
55329
55330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55331   int jresult ;
55332   int result;
55333
55334   {
55335     try {
55336       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55337     } catch (std::out_of_range& e) {
55338       {
55339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55340       };
55341     } catch (std::exception& e) {
55342       {
55343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55344       };
55345     } catch (Dali::DaliException e) {
55346       {
55347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55348       };
55349     } catch (...) {
55350       {
55351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55352       };
55353     }
55354   }
55355
55356   jresult = (int)result;
55357   return jresult;
55358 }
55359
55360
55361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55362   int jresult ;
55363   int result;
55364
55365   {
55366     try {
55367       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55368     } catch (std::out_of_range& e) {
55369       {
55370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55371       };
55372     } catch (std::exception& e) {
55373       {
55374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55375       };
55376     } catch (Dali::DaliException e) {
55377       {
55378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55379       };
55380     } catch (...) {
55381       {
55382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55383       };
55384     }
55385   }
55386
55387   jresult = (int)result;
55388   return jresult;
55389 }
55390
55391
55392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55393   int jresult ;
55394   int result;
55395
55396   {
55397     try {
55398       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55399     } catch (std::out_of_range& e) {
55400       {
55401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55402       };
55403     } catch (std::exception& e) {
55404       {
55405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55406       };
55407     } catch (Dali::DaliException e) {
55408       {
55409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55410       };
55411     } catch (...) {
55412       {
55413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55414       };
55415     }
55416   }
55417
55418   jresult = (int)result;
55419   return jresult;
55420 }
55421
55422
55423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55424   int jresult ;
55425   int result;
55426
55427   {
55428     try {
55429       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55430     } catch (std::out_of_range& e) {
55431       {
55432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55433       };
55434     } catch (std::exception& e) {
55435       {
55436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55437       };
55438     } catch (Dali::DaliException e) {
55439       {
55440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55441       };
55442     } catch (...) {
55443       {
55444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55445       };
55446     }
55447   }
55448
55449   jresult = (int)result;
55450   return jresult;
55451 }
55452
55453
55454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55455   int jresult ;
55456   int result;
55457
55458   {
55459     try {
55460       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55461     } catch (std::out_of_range& e) {
55462       {
55463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55464       };
55465     } catch (std::exception& e) {
55466       {
55467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55468       };
55469     } catch (Dali::DaliException e) {
55470       {
55471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55472       };
55473     } catch (...) {
55474       {
55475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55476       };
55477     }
55478   }
55479
55480   jresult = (int)result;
55481   return jresult;
55482 }
55483
55484
55485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55486   int jresult ;
55487   int result;
55488
55489   {
55490     try {
55491       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55492     } catch (std::out_of_range& e) {
55493       {
55494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55495       };
55496     } catch (std::exception& e) {
55497       {
55498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55499       };
55500     } catch (Dali::DaliException e) {
55501       {
55502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55503       };
55504     } catch (...) {
55505       {
55506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55507       };
55508     }
55509   }
55510
55511   jresult = (int)result;
55512   return jresult;
55513 }
55514
55515
55516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
55517   int jresult ;
55518   int result;
55519
55520   {
55521     try {
55522       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55523     } catch (std::out_of_range& e) {
55524       {
55525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55526       };
55527     } catch (std::exception& e) {
55528       {
55529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55530       };
55531     } catch (Dali::DaliException e) {
55532       {
55533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55534       };
55535     } catch (...) {
55536       {
55537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55538       };
55539     }
55540   }
55541
55542   jresult = (int)result;
55543   return jresult;
55544 }
55545
55546
55547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
55548   int jresult ;
55549   int result;
55550
55551   {
55552     try {
55553       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
55554     } catch (std::out_of_range& e) {
55555       {
55556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55557       };
55558     } catch (std::exception& e) {
55559       {
55560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55561       };
55562     } catch (Dali::DaliException e) {
55563       {
55564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55565       };
55566     } catch (...) {
55567       {
55568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55569       };
55570     }
55571   }
55572
55573   jresult = (int)result;
55574   return jresult;
55575 }
55576
55577
55578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
55579   int jresult ;
55580   int result;
55581
55582   {
55583     try {
55584       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
55585     } catch (std::out_of_range& e) {
55586       {
55587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55588       };
55589     } catch (std::exception& e) {
55590       {
55591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55592       };
55593     } catch (Dali::DaliException e) {
55594       {
55595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55596       };
55597     } catch (...) {
55598       {
55599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55600       };
55601     }
55602   }
55603
55604   jresult = (int)result;
55605   return jresult;
55606 }
55607
55608
55609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
55610   int jresult ;
55611   int result;
55612
55613   {
55614     try {
55615       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
55616     } catch (std::out_of_range& e) {
55617       {
55618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55619       };
55620     } catch (std::exception& e) {
55621       {
55622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55623       };
55624     } catch (Dali::DaliException e) {
55625       {
55626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55627       };
55628     } catch (...) {
55629       {
55630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55631       };
55632     }
55633   }
55634
55635   jresult = (int)result;
55636   return jresult;
55637 }
55638
55639
55640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
55641   int jresult ;
55642   int result;
55643
55644   {
55645     try {
55646       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
55647     } catch (std::out_of_range& e) {
55648       {
55649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55650       };
55651     } catch (std::exception& e) {
55652       {
55653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55654       };
55655     } catch (Dali::DaliException e) {
55656       {
55657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55658       };
55659     } catch (...) {
55660       {
55661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55662       };
55663     }
55664   }
55665
55666   jresult = (int)result;
55667   return jresult;
55668 }
55669
55670
55671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
55672   int jresult ;
55673   int result;
55674
55675   {
55676     try {
55677       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
55678     } catch (std::out_of_range& e) {
55679       {
55680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55681       };
55682     } catch (std::exception& e) {
55683       {
55684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55685       };
55686     } catch (Dali::DaliException e) {
55687       {
55688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55689       };
55690     } catch (...) {
55691       {
55692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55693       };
55694     }
55695   }
55696
55697   jresult = (int)result;
55698   return jresult;
55699 }
55700
55701
55702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
55703   int jresult ;
55704   int result;
55705
55706   {
55707     try {
55708       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
55709     } catch (std::out_of_range& e) {
55710       {
55711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55712       };
55713     } catch (std::exception& e) {
55714       {
55715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55716       };
55717     } catch (Dali::DaliException e) {
55718       {
55719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55720       };
55721     } catch (...) {
55722       {
55723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55724       };
55725     }
55726   }
55727
55728   jresult = (int)result;
55729   return jresult;
55730 }
55731
55732
55733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
55734   int jresult ;
55735   int result;
55736
55737   {
55738     try {
55739       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
55740     } catch (std::out_of_range& e) {
55741       {
55742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55743       };
55744     } catch (std::exception& e) {
55745       {
55746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55747       };
55748     } catch (Dali::DaliException e) {
55749       {
55750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55751       };
55752     } catch (...) {
55753       {
55754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55755       };
55756     }
55757   }
55758
55759   jresult = (int)result;
55760   return jresult;
55761 }
55762
55763
55764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
55765   int jresult ;
55766   int result;
55767
55768   {
55769     try {
55770       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
55771     } catch (std::out_of_range& e) {
55772       {
55773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55774       };
55775     } catch (std::exception& e) {
55776       {
55777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55778       };
55779     } catch (Dali::DaliException e) {
55780       {
55781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55782       };
55783     } catch (...) {
55784       {
55785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55786       };
55787     }
55788   }
55789
55790   jresult = (int)result;
55791   return jresult;
55792 }
55793
55794
55795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
55796   int jresult ;
55797   int result;
55798
55799   {
55800     try {
55801       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
55802     } catch (std::out_of_range& e) {
55803       {
55804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55805       };
55806     } catch (std::exception& e) {
55807       {
55808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55809       };
55810     } catch (Dali::DaliException e) {
55811       {
55812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55813       };
55814     } catch (...) {
55815       {
55816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55817       };
55818     }
55819   }
55820
55821   jresult = (int)result;
55822   return jresult;
55823 }
55824
55825
55826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
55827   int jresult ;
55828   int result;
55829
55830   {
55831     try {
55832       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
55833     } catch (std::out_of_range& e) {
55834       {
55835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55836       };
55837     } catch (std::exception& e) {
55838       {
55839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55840       };
55841     } catch (Dali::DaliException e) {
55842       {
55843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55844       };
55845     } catch (...) {
55846       {
55847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55848       };
55849     }
55850   }
55851
55852   jresult = (int)result;
55853   return jresult;
55854 }
55855
55856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
55857   int jresult ;
55858   int result;
55859
55860   {
55861     try {
55862       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
55863     } catch (std::out_of_range& e) {
55864       {
55865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55866       };
55867     } catch (std::exception& e) {
55868       {
55869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55870       };
55871     } catch (Dali::DaliException e) {
55872       {
55873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55874       };
55875     } catch (...) {
55876       {
55877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55878       };
55879     }
55880   }
55881
55882   jresult = (int)result;
55883   return jresult;
55884 }
55885
55886
55887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
55888   int jresult ;
55889   int result;
55890   {
55891     try
55892     {
55893       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
55894     } catch (std::out_of_range& e) {
55895       {
55896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55897       };
55898     } catch (std::exception& e) {
55899       {
55900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55901       };
55902     } catch (Dali::DaliException e) {
55903       {
55904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55905       };
55906     } catch (...) {
55907       {
55908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55909       };
55910     }
55911   }
55912
55913   jresult = (int)result;
55914   return jresult;
55915 }
55916
55917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
55918   int jresult ;
55919   int result;
55920   {
55921     try
55922     {
55923       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
55924     } catch (std::out_of_range& e) {
55925       {
55926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55927       };
55928     } catch (std::exception& e) {
55929       {
55930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55931       };
55932     } catch (Dali::DaliException e) {
55933       {
55934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55935       };
55936     } catch (...) {
55937       {
55938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55939       };
55940     }
55941   }
55942
55943   jresult = (int)result;
55944   return jresult;
55945 }
55946
55947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
55948   int jresult ;
55949   int result;
55950   {
55951     try
55952     {
55953       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
55954     } catch (std::out_of_range& e) {
55955       {
55956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55957       };
55958     } catch (std::exception& e) {
55959       {
55960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55961       };
55962     } catch (Dali::DaliException e) {
55963       {
55964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55965       };
55966     } catch (...) {
55967       {
55968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55969       };
55970     }
55971   }
55972
55973   jresult = (int)result;
55974   return jresult;
55975 }
55976
55977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
55978   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
55979 }
55980
55981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
55982   int jresult ;
55983   int result;
55984   {
55985     try
55986     {
55987       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
55988     } catch (std::out_of_range& e) {
55989       {
55990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55991       };
55992     } catch (std::exception& e) {
55993       {
55994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55995       };
55996     } catch (Dali::DaliException e) {
55997       {
55998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55999       };
56000     } catch (...) {
56001       {
56002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56003       };
56004     }
56005   }
56006
56007   jresult = (int)result;
56008   return jresult;
56009 }
56010
56011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
56012   int jresult ;
56013   int result;
56014   {
56015     try
56016     {
56017       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
56018     } catch (std::out_of_range& e) {
56019       {
56020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56021       };
56022     } catch (std::exception& e) {
56023       {
56024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56025       };
56026     } catch (Dali::DaliException e) {
56027       {
56028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56029       };
56030     } catch (...) {
56031       {
56032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56033       };
56034     }
56035   }
56036
56037   jresult = (int)result;
56038   return jresult;
56039 }
56040
56041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
56042   int jresult ;
56043   int result;
56044
56045   {
56046     try {
56047       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
56048     } catch (std::out_of_range& e) {
56049       {
56050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56051       };
56052     } catch (std::exception& e) {
56053       {
56054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56055       };
56056     } catch (Dali::DaliException e) {
56057       {
56058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56059       };
56060     } catch (...) {
56061       {
56062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56063       };
56064     }
56065   }
56066
56067   jresult = (int)result;
56068   return jresult;
56069 }
56070
56071
56072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
56073   int jresult ;
56074   int result;
56075
56076   {
56077     try {
56078       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
56079     } catch (std::out_of_range& e) {
56080       {
56081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56082       };
56083     } catch (std::exception& e) {
56084       {
56085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56086       };
56087     } catch (Dali::DaliException e) {
56088       {
56089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56090       };
56091     } catch (...) {
56092       {
56093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56094       };
56095     }
56096   }
56097
56098   jresult = (int)result;
56099   return jresult;
56100 }
56101
56102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
56103   int jresult ;
56104   int result;
56105   {
56106     try
56107     {
56108       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
56109     } catch (std::out_of_range& e) {
56110       {
56111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56112       };
56113     } catch (std::exception& e) {
56114       {
56115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56116       };
56117     } catch (...) {
56118       {
56119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56120       };
56121     }
56122   }
56123   jresult = (int)result;
56124   return jresult;
56125 }
56126
56127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
56128   int jresult ;
56129   int result;
56130   {
56131     try
56132     {
56133       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
56134     } catch (std::out_of_range& e) {
56135       {
56136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56137       };
56138     } catch (std::exception& e) {
56139       {
56140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56141       };
56142     } catch (...) {
56143       {
56144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56145       };
56146     }
56147   }
56148   jresult = (int)result;
56149   return jresult;
56150 }
56151
56152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
56153   int jresult ;
56154   int result;
56155   {
56156     try
56157     {
56158       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
56159     } catch (std::out_of_range& e) {
56160       {
56161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56162       };
56163     } catch (std::exception& e) {
56164       {
56165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56166       };
56167     } catch (...) {
56168       {
56169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56170       };
56171     }
56172   }
56173   jresult = (int)result;
56174   return jresult;
56175 }
56176
56177
56178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
56179   int jresult ;
56180   int result;
56181   {
56182     try
56183     {
56184       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
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 (...) {
56194       {
56195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56196       };
56197     }
56198   }
56199   jresult = (int)result;
56200   return jresult;
56201 }
56202
56203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
56204   int jresult ;
56205   int result;
56206   {
56207     try
56208     {
56209       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
56210     } catch (std::out_of_range& e) {
56211       {
56212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56213       };
56214     } catch (std::exception& e) {
56215       {
56216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56217       };
56218     } catch (...) {
56219       {
56220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56221       };
56222     }
56223   }
56224   jresult = (int)result;
56225   return jresult;
56226 }
56227
56228
56229
56230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56231   int jresult ;
56232   int result;
56233
56234   {
56235     try {
56236       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56237     } catch (std::out_of_range& e) {
56238       {
56239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56240       };
56241     } catch (std::exception& e) {
56242       {
56243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56244       };
56245     } catch (Dali::DaliException e) {
56246       {
56247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56248       };
56249     } catch (...) {
56250       {
56251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56252       };
56253     }
56254   }
56255
56256   jresult = (int)result;
56257   return jresult;
56258 }
56259
56260
56261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56262   int jresult ;
56263   int result;
56264
56265   {
56266     try {
56267       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56268     } catch (std::out_of_range& e) {
56269       {
56270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56271       };
56272     } catch (std::exception& e) {
56273       {
56274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56275       };
56276     } catch (Dali::DaliException e) {
56277       {
56278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56279       };
56280     } catch (...) {
56281       {
56282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56283       };
56284     }
56285   }
56286
56287   jresult = (int)result;
56288   return jresult;
56289 }
56290
56291
56292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56293   int jresult ;
56294   int result;
56295
56296   {
56297     try {
56298       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56299     } catch (std::out_of_range& e) {
56300       {
56301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56302       };
56303     } catch (std::exception& e) {
56304       {
56305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56306       };
56307     } catch (Dali::DaliException e) {
56308       {
56309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56310       };
56311     } catch (...) {
56312       {
56313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56314       };
56315     }
56316   }
56317
56318   jresult = (int)result;
56319   return jresult;
56320 }
56321
56322
56323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56324   int jresult ;
56325   int result;
56326
56327   {
56328     try {
56329       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56330     } catch (std::out_of_range& e) {
56331       {
56332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56333       };
56334     } catch (std::exception& e) {
56335       {
56336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56337       };
56338     } catch (Dali::DaliException e) {
56339       {
56340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56341       };
56342     } catch (...) {
56343       {
56344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56345       };
56346     }
56347   }
56348
56349   jresult = (int)result;
56350   return jresult;
56351 }
56352
56353
56354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56355   int jresult ;
56356   int result;
56357
56358   {
56359     try {
56360       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56361     } catch (std::out_of_range& e) {
56362       {
56363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56364       };
56365     } catch (std::exception& e) {
56366       {
56367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56368       };
56369     } catch (Dali::DaliException e) {
56370       {
56371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56372       };
56373     } catch (...) {
56374       {
56375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56376       };
56377     }
56378   }
56379
56380   jresult = (int)result;
56381   return jresult;
56382 }
56383
56384
56385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56386   int jresult ;
56387   int result;
56388
56389   {
56390     try {
56391       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56392     } catch (std::out_of_range& e) {
56393       {
56394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56395       };
56396     } catch (std::exception& e) {
56397       {
56398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56399       };
56400     } catch (Dali::DaliException e) {
56401       {
56402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56403       };
56404     } catch (...) {
56405       {
56406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56407       };
56408     }
56409   }
56410
56411   jresult = (int)result;
56412   return jresult;
56413 }
56414
56415
56416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56417   int jresult ;
56418   int result;
56419
56420   {
56421     try {
56422       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56423     } catch (std::out_of_range& e) {
56424       {
56425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56426       };
56427     } catch (std::exception& e) {
56428       {
56429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56430       };
56431     } catch (Dali::DaliException e) {
56432       {
56433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56434       };
56435     } catch (...) {
56436       {
56437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56438       };
56439     }
56440   }
56441
56442   jresult = (int)result;
56443   return jresult;
56444 }
56445
56446 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
56447   int jresult ;
56448   int result;
56449
56450   {
56451     try {
56452       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
56453     } catch (std::out_of_range& e) {
56454       {
56455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56456       };
56457     } catch (std::exception& e) {
56458       {
56459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56460       };
56461     } catch (...) {
56462       {
56463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56464       };
56465     }
56466   }
56467   jresult = (int)result;
56468   return jresult;
56469 }
56470
56471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56472   int jresult ;
56473   int result;
56474
56475   {
56476     try {
56477       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56478     } catch (std::out_of_range& e) {
56479       {
56480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56481       };
56482     } catch (std::exception& e) {
56483       {
56484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56485       };
56486     } catch (Dali::DaliException e) {
56487       {
56488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56489       };
56490     } catch (...) {
56491       {
56492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56493       };
56494     }
56495   }
56496
56497   jresult = (int)result;
56498   return jresult;
56499 }
56500
56501
56502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56503   int jresult ;
56504   int result;
56505
56506   {
56507     try {
56508       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56509     } catch (std::out_of_range& e) {
56510       {
56511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56512       };
56513     } catch (std::exception& e) {
56514       {
56515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56516       };
56517     } catch (Dali::DaliException e) {
56518       {
56519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56520       };
56521     } catch (...) {
56522       {
56523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56524       };
56525     }
56526   }
56527
56528   jresult = (int)result;
56529   return jresult;
56530 }
56531
56532
56533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56534   int jresult ;
56535   int result;
56536
56537   {
56538     try {
56539       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56540     } catch (std::out_of_range& e) {
56541       {
56542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56543       };
56544     } catch (std::exception& e) {
56545       {
56546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56547       };
56548     } catch (Dali::DaliException e) {
56549       {
56550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56551       };
56552     } catch (...) {
56553       {
56554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56555       };
56556     }
56557   }
56558
56559   jresult = (int)result;
56560   return jresult;
56561 }
56562
56563
56564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56565   int jresult ;
56566   int result;
56567
56568   {
56569     try {
56570       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56571     } catch (std::out_of_range& e) {
56572       {
56573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56574       };
56575     } catch (std::exception& e) {
56576       {
56577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56578       };
56579     } catch (Dali::DaliException e) {
56580       {
56581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56582       };
56583     } catch (...) {
56584       {
56585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56586       };
56587     }
56588   }
56589
56590   jresult = (int)result;
56591   return jresult;
56592 }
56593
56594
56595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56596   int jresult ;
56597   int result;
56598
56599   {
56600     try {
56601       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56602     } catch (std::out_of_range& e) {
56603       {
56604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56605       };
56606     } catch (std::exception& e) {
56607       {
56608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56609       };
56610     } catch (Dali::DaliException e) {
56611       {
56612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56613       };
56614     } catch (...) {
56615       {
56616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56617       };
56618     }
56619   }
56620
56621   jresult = (int)result;
56622   return jresult;
56623 }
56624
56625
56626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56627   int jresult ;
56628   int result;
56629
56630   {
56631     try {
56632       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56633     } catch (std::out_of_range& e) {
56634       {
56635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56636       };
56637     } catch (std::exception& e) {
56638       {
56639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56640       };
56641     } catch (Dali::DaliException e) {
56642       {
56643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56644       };
56645     } catch (...) {
56646       {
56647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56648       };
56649     }
56650   }
56651
56652   jresult = (int)result;
56653   return jresult;
56654 }
56655
56656
56657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56658   int jresult ;
56659   int result;
56660
56661   {
56662     try {
56663       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56664     } catch (std::out_of_range& e) {
56665       {
56666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56667       };
56668     } catch (std::exception& e) {
56669       {
56670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56671       };
56672     } catch (Dali::DaliException e) {
56673       {
56674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56675       };
56676     } catch (...) {
56677       {
56678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56679       };
56680     }
56681   }
56682
56683   jresult = (int)result;
56684   return jresult;
56685 }
56686
56687
56688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56689   int jresult ;
56690   int result;
56691
56692   {
56693     try {
56694       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56695     } catch (std::out_of_range& e) {
56696       {
56697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56698       };
56699     } catch (std::exception& e) {
56700       {
56701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56702       };
56703     } catch (Dali::DaliException e) {
56704       {
56705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56706       };
56707     } catch (...) {
56708       {
56709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56710       };
56711     }
56712   }
56713
56714   jresult = (int)result;
56715   return jresult;
56716 }
56717
56718
56719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56720   int jresult ;
56721   int result;
56722
56723   {
56724     try {
56725       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56726     } catch (std::out_of_range& e) {
56727       {
56728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56729       };
56730     } catch (std::exception& e) {
56731       {
56732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56733       };
56734     } catch (Dali::DaliException e) {
56735       {
56736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56737       };
56738     } catch (...) {
56739       {
56740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56741       };
56742     }
56743   }
56744
56745   jresult = (int)result;
56746   return jresult;
56747 }
56748
56749
56750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56751   int jresult ;
56752   int result;
56753
56754   {
56755     try {
56756       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56757     } catch (std::out_of_range& e) {
56758       {
56759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56760       };
56761     } catch (std::exception& e) {
56762       {
56763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56764       };
56765     } catch (Dali::DaliException e) {
56766       {
56767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56768       };
56769     } catch (...) {
56770       {
56771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56772       };
56773     }
56774   }
56775
56776   jresult = (int)result;
56777   return jresult;
56778 }
56779
56780
56781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
56782   int jresult ;
56783   int result;
56784
56785   {
56786     try {
56787       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56788     } catch (std::out_of_range& e) {
56789       {
56790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56791       };
56792     } catch (std::exception& e) {
56793       {
56794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56795       };
56796     } catch (Dali::DaliException e) {
56797       {
56798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56799       };
56800     } catch (...) {
56801       {
56802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56803       };
56804     }
56805   }
56806
56807   jresult = (int)result;
56808   return jresult;
56809 }
56810
56811
56812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
56813   int jresult ;
56814   int result;
56815
56816   {
56817     try {
56818       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56819     } catch (std::out_of_range& e) {
56820       {
56821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56822       };
56823     } catch (std::exception& e) {
56824       {
56825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56826       };
56827     } catch (Dali::DaliException e) {
56828       {
56829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56830       };
56831     } catch (...) {
56832       {
56833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56834       };
56835     }
56836   }
56837
56838   jresult = (int)result;
56839   return jresult;
56840 }
56841
56842
56843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
56844   int jresult ;
56845   int result;
56846
56847   {
56848     try {
56849       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
56850     } catch (std::out_of_range& e) {
56851       {
56852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56853       };
56854     } catch (std::exception& e) {
56855       {
56856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56857       };
56858     } catch (Dali::DaliException e) {
56859       {
56860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56861       };
56862     } catch (...) {
56863       {
56864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56865       };
56866     }
56867   }
56868
56869   jresult = (int)result;
56870   return jresult;
56871 }
56872
56873
56874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
56875   int jresult ;
56876   int result;
56877
56878   {
56879     try {
56880       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
56881     } catch (std::out_of_range& e) {
56882       {
56883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56884       };
56885     } catch (std::exception& e) {
56886       {
56887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56888       };
56889     } catch (Dali::DaliException e) {
56890       {
56891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56892       };
56893     } catch (...) {
56894       {
56895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56896       };
56897     }
56898   }
56899
56900   jresult = (int)result;
56901   return jresult;
56902 }
56903
56904
56905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
56906   int jresult ;
56907   int result;
56908
56909   {
56910     try {
56911       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
56912     } catch (std::out_of_range& e) {
56913       {
56914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56915       };
56916     } catch (std::exception& e) {
56917       {
56918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56919       };
56920     } catch (Dali::DaliException e) {
56921       {
56922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56923       };
56924     } catch (...) {
56925       {
56926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56927       };
56928     }
56929   }
56930
56931   jresult = (int)result;
56932   return jresult;
56933 }
56934
56935
56936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
56937   int jresult ;
56938   int result;
56939
56940   {
56941     try {
56942       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
56943     } catch (std::out_of_range& e) {
56944       {
56945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56946       };
56947     } catch (std::exception& e) {
56948       {
56949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56950       };
56951     } catch (Dali::DaliException e) {
56952       {
56953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56954       };
56955     } catch (...) {
56956       {
56957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56958       };
56959     }
56960   }
56961
56962   jresult = (int)result;
56963   return jresult;
56964 }
56965
56966
56967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
56968   int jresult ;
56969   int result;
56970
56971   {
56972     try {
56973       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
56974     } catch (std::out_of_range& e) {
56975       {
56976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56977       };
56978     } catch (std::exception& e) {
56979       {
56980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56981       };
56982     } catch (Dali::DaliException e) {
56983       {
56984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56985       };
56986     } catch (...) {
56987       {
56988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56989       };
56990     }
56991   }
56992
56993   jresult = (int)result;
56994   return jresult;
56995 }
56996
56997
56998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
56999   int jresult ;
57000   int result;
57001
57002   {
57003     try {
57004       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
57005     } catch (std::out_of_range& e) {
57006       {
57007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57008       };
57009     } catch (std::exception& e) {
57010       {
57011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57012       };
57013     } catch (Dali::DaliException e) {
57014       {
57015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57016       };
57017     } catch (...) {
57018       {
57019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57020       };
57021     }
57022   }
57023
57024   jresult = (int)result;
57025   return jresult;
57026 }
57027
57028
57029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
57030   int jresult ;
57031   int result;
57032
57033   {
57034     try {
57035       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
57036     } catch (std::out_of_range& e) {
57037       {
57038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57039       };
57040     } catch (std::exception& e) {
57041       {
57042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57043       };
57044     } catch (Dali::DaliException e) {
57045       {
57046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57047       };
57048     } catch (...) {
57049       {
57050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57051       };
57052     }
57053   }
57054
57055   jresult = (int)result;
57056   return jresult;
57057 }
57058
57059
57060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
57061   int jresult ;
57062   int result;
57063
57064   {
57065     try {
57066       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
57067     } catch (std::out_of_range& e) {
57068       {
57069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57070       };
57071     } catch (std::exception& e) {
57072       {
57073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57074       };
57075     } catch (Dali::DaliException e) {
57076       {
57077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57078       };
57079     } catch (...) {
57080       {
57081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57082       };
57083     }
57084   }
57085
57086   jresult = (int)result;
57087   return jresult;
57088 }
57089
57090
57091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
57092   int jresult ;
57093   int result;
57094
57095   {
57096     try {
57097       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
57098     } catch (std::out_of_range& e) {
57099       {
57100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57101       };
57102     } catch (std::exception& e) {
57103       {
57104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57105       };
57106     } catch (Dali::DaliException e) {
57107       {
57108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57109       };
57110     } catch (...) {
57111       {
57112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57113       };
57114     }
57115   }
57116
57117   jresult = (int)result;
57118   return jresult;
57119 }
57120
57121
57122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
57123   int jresult ;
57124   int result;
57125
57126   {
57127     try {
57128       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
57129     } catch (std::out_of_range& e) {
57130       {
57131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57132       };
57133     } catch (std::exception& e) {
57134       {
57135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57136       };
57137     } catch (Dali::DaliException e) {
57138       {
57139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57140       };
57141     } catch (...) {
57142       {
57143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57144       };
57145     }
57146   }
57147
57148   jresult = (int)result;
57149   return jresult;
57150 }
57151
57152
57153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
57154   int jresult ;
57155   int result;
57156
57157   {
57158     try {
57159       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
57160     } catch (std::out_of_range& e) {
57161       {
57162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57163       };
57164     } catch (std::exception& e) {
57165       {
57166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57167       };
57168     } catch (Dali::DaliException e) {
57169       {
57170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57171       };
57172     } catch (...) {
57173       {
57174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57175       };
57176     }
57177   }
57178
57179   jresult = (int)result;
57180   return jresult;
57181 }
57182
57183
57184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57185   int jresult ;
57186   int result;
57187
57188   {
57189     try {
57190       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57191     } catch (std::out_of_range& e) {
57192       {
57193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57194       };
57195     } catch (std::exception& e) {
57196       {
57197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57198       };
57199     } catch (Dali::DaliException e) {
57200       {
57201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57202       };
57203     } catch (...) {
57204       {
57205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57206       };
57207     }
57208   }
57209
57210   jresult = (int)result;
57211   return jresult;
57212 }
57213
57214
57215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57216   int jresult ;
57217   int result;
57218
57219   {
57220     try {
57221       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57222     } catch (std::out_of_range& e) {
57223       {
57224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57225       };
57226     } catch (std::exception& e) {
57227       {
57228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57229       };
57230     } catch (Dali::DaliException e) {
57231       {
57232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57233       };
57234     } catch (...) {
57235       {
57236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57237       };
57238     }
57239   }
57240
57241   jresult = (int)result;
57242   return jresult;
57243 }
57244
57245
57246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57247   int jresult ;
57248   int result;
57249
57250   {
57251     try {
57252       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57253     } catch (std::out_of_range& e) {
57254       {
57255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57256       };
57257     } catch (std::exception& e) {
57258       {
57259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57260       };
57261     } catch (Dali::DaliException e) {
57262       {
57263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57264       };
57265     } catch (...) {
57266       {
57267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57268       };
57269     }
57270   }
57271
57272   jresult = (int)result;
57273   return jresult;
57274 }
57275
57276
57277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57278   int jresult ;
57279   int result;
57280
57281   {
57282     try {
57283       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57284     } catch (std::out_of_range& e) {
57285       {
57286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57287       };
57288     } catch (std::exception& e) {
57289       {
57290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57291       };
57292     } catch (Dali::DaliException e) {
57293       {
57294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57295       };
57296     } catch (...) {
57297       {
57298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57299       };
57300     }
57301   }
57302
57303   jresult = (int)result;
57304   return jresult;
57305 }
57306
57307
57308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57309   int jresult ;
57310   int result;
57311
57312   {
57313     try {
57314       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57315     } catch (std::out_of_range& e) {
57316       {
57317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57318       };
57319     } catch (std::exception& e) {
57320       {
57321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57322       };
57323     } catch (Dali::DaliException e) {
57324       {
57325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57326       };
57327     } catch (...) {
57328       {
57329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57330       };
57331     }
57332   }
57333
57334   jresult = (int)result;
57335   return jresult;
57336 }
57337
57338
57339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57340   void * jresult ;
57341   Dali::Toolkit::Builder *result = 0 ;
57342
57343   {
57344     try {
57345       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57346     } catch (std::out_of_range& e) {
57347       {
57348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57349       };
57350     } catch (std::exception& e) {
57351       {
57352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57353       };
57354     } catch (Dali::DaliException e) {
57355       {
57356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57357       };
57358     } catch (...) {
57359       {
57360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57361       };
57362     }
57363   }
57364
57365   jresult = (void *)result;
57366   return jresult;
57367 }
57368
57369
57370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57371   void * jresult ;
57372   Dali::Toolkit::Builder result;
57373
57374   {
57375     try {
57376       result = Dali::Toolkit::Builder::New();
57377     } catch (std::out_of_range& e) {
57378       {
57379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57380       };
57381     } catch (std::exception& e) {
57382       {
57383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57384       };
57385     } catch (Dali::DaliException e) {
57386       {
57387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57388       };
57389     } catch (...) {
57390       {
57391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57392       };
57393     }
57394   }
57395
57396   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57397   return jresult;
57398 }
57399
57400
57401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57402   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57403
57404   arg1 = (Dali::Toolkit::Builder *)jarg1;
57405   {
57406     try {
57407       delete arg1;
57408     } catch (std::out_of_range& e) {
57409       {
57410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57411       };
57412     } catch (std::exception& e) {
57413       {
57414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57415       };
57416     } catch (Dali::DaliException e) {
57417       {
57418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57419       };
57420     } catch (...) {
57421       {
57422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57423       };
57424     }
57425   }
57426
57427 }
57428
57429
57430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57431   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57432   std::string *arg2 = 0 ;
57433   Dali::Toolkit::Builder::UIFormat arg3 ;
57434
57435   arg1 = (Dali::Toolkit::Builder *)jarg1;
57436   if (!jarg2) {
57437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57438     return ;
57439   }
57440   std::string arg2_str(jarg2);
57441   arg2 = &arg2_str;
57442   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57443   {
57444     try {
57445       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57446     } catch (std::out_of_range& e) {
57447       {
57448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57449       };
57450     } catch (std::exception& e) {
57451       {
57452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57453       };
57454     } catch (Dali::DaliException e) {
57455       {
57456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57457       };
57458     } catch (...) {
57459       {
57460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57461       };
57462     }
57463   }
57464
57465
57466   //argout typemap for const std::string&
57467
57468 }
57469
57470
57471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57472   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57473   std::string *arg2 = 0 ;
57474
57475   arg1 = (Dali::Toolkit::Builder *)jarg1;
57476   if (!jarg2) {
57477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57478     return ;
57479   }
57480   std::string arg2_str(jarg2);
57481   arg2 = &arg2_str;
57482   {
57483     try {
57484       (arg1)->LoadFromString((std::string const &)*arg2);
57485     } catch (std::out_of_range& e) {
57486       {
57487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57488       };
57489     } catch (std::exception& e) {
57490       {
57491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57492       };
57493     } catch (Dali::DaliException e) {
57494       {
57495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57496       };
57497     } catch (...) {
57498       {
57499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57500       };
57501     }
57502   }
57503
57504
57505   //argout typemap for const std::string&
57506
57507 }
57508
57509
57510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57511   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57512   Dali::Property::Map *arg2 = 0 ;
57513
57514   arg1 = (Dali::Toolkit::Builder *)jarg1;
57515   arg2 = (Dali::Property::Map *)jarg2;
57516   if (!arg2) {
57517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57518     return ;
57519   }
57520   {
57521     try {
57522       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57523     } catch (std::out_of_range& e) {
57524       {
57525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57526       };
57527     } catch (std::exception& e) {
57528       {
57529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57530       };
57531     } catch (Dali::DaliException e) {
57532       {
57533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57534       };
57535     } catch (...) {
57536       {
57537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57538       };
57539     }
57540   }
57541
57542 }
57543
57544
57545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57546   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57547   std::string *arg2 = 0 ;
57548   Dali::Property::Value *arg3 = 0 ;
57549
57550   arg1 = (Dali::Toolkit::Builder *)jarg1;
57551   if (!jarg2) {
57552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57553     return ;
57554   }
57555   std::string arg2_str(jarg2);
57556   arg2 = &arg2_str;
57557   arg3 = (Dali::Property::Value *)jarg3;
57558   if (!arg3) {
57559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57560     return ;
57561   }
57562   {
57563     try {
57564       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57565     } catch (std::out_of_range& e) {
57566       {
57567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57568       };
57569     } catch (std::exception& e) {
57570       {
57571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57572       };
57573     } catch (Dali::DaliException e) {
57574       {
57575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57576       };
57577     } catch (...) {
57578       {
57579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57580       };
57581     }
57582   }
57583
57584
57585   //argout typemap for const std::string&
57586
57587 }
57588
57589
57590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57591   void * jresult ;
57592   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57593   Dali::Property::Map *result = 0 ;
57594
57595   arg1 = (Dali::Toolkit::Builder *)jarg1;
57596   {
57597     try {
57598       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57599     } catch (std::out_of_range& e) {
57600       {
57601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57602       };
57603     } catch (std::exception& e) {
57604       {
57605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57606       };
57607     } catch (Dali::DaliException e) {
57608       {
57609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57610       };
57611     } catch (...) {
57612       {
57613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57614       };
57615     }
57616   }
57617
57618   jresult = (void *)result;
57619   return jresult;
57620 }
57621
57622
57623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57624   void * jresult ;
57625   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57626   std::string *arg2 = 0 ;
57627   Dali::Property::Value *result = 0 ;
57628
57629   arg1 = (Dali::Toolkit::Builder *)jarg1;
57630   if (!jarg2) {
57631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57632     return 0;
57633   }
57634   std::string arg2_str(jarg2);
57635   arg2 = &arg2_str;
57636   {
57637     try {
57638       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57639     } catch (std::out_of_range& e) {
57640       {
57641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57642       };
57643     } catch (std::exception& e) {
57644       {
57645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57646       };
57647     } catch (Dali::DaliException e) {
57648       {
57649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57650       };
57651     } catch (...) {
57652       {
57653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57654       };
57655     }
57656   }
57657
57658   jresult = (void *)result;
57659
57660   //argout typemap for const std::string&
57661
57662   return jresult;
57663 }
57664
57665
57666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57667   void * jresult ;
57668   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57669   std::string *arg2 = 0 ;
57670   Dali::Animation result;
57671
57672   arg1 = (Dali::Toolkit::Builder *)jarg1;
57673   if (!jarg2) {
57674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57675     return 0;
57676   }
57677   std::string arg2_str(jarg2);
57678   arg2 = &arg2_str;
57679   {
57680     try {
57681       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57682     } catch (std::out_of_range& e) {
57683       {
57684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57685       };
57686     } catch (std::exception& e) {
57687       {
57688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57689       };
57690     } catch (Dali::DaliException e) {
57691       {
57692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57693       };
57694     } catch (...) {
57695       {
57696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57697       };
57698     }
57699   }
57700
57701   jresult = new Dali::Animation((const Dali::Animation &)result);
57702
57703   //argout typemap for const std::string&
57704
57705   return jresult;
57706 }
57707
57708
57709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57710   void * jresult ;
57711   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57712   std::string *arg2 = 0 ;
57713   Dali::Property::Map *arg3 = 0 ;
57714   Dali::Animation result;
57715
57716   arg1 = (Dali::Toolkit::Builder *)jarg1;
57717   if (!jarg2) {
57718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57719     return 0;
57720   }
57721   std::string arg2_str(jarg2);
57722   arg2 = &arg2_str;
57723   arg3 = (Dali::Property::Map *)jarg3;
57724   if (!arg3) {
57725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57726     return 0;
57727   }
57728   {
57729     try {
57730       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57731     } catch (std::out_of_range& e) {
57732       {
57733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57734       };
57735     } catch (std::exception& e) {
57736       {
57737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57738       };
57739     } catch (Dali::DaliException e) {
57740       {
57741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57742       };
57743     } catch (...) {
57744       {
57745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57746       };
57747     }
57748   }
57749
57750   jresult = new Dali::Animation((const Dali::Animation &)result);
57751
57752   //argout typemap for const std::string&
57753
57754   return jresult;
57755 }
57756
57757
57758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57759   void * jresult ;
57760   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57761   std::string *arg2 = 0 ;
57762   Dali::Actor arg3 ;
57763   Dali::Actor *argp3 ;
57764   Dali::Animation result;
57765
57766   arg1 = (Dali::Toolkit::Builder *)jarg1;
57767   if (!jarg2) {
57768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57769     return 0;
57770   }
57771   std::string arg2_str(jarg2);
57772   arg2 = &arg2_str;
57773   argp3 = (Dali::Actor *)jarg3;
57774   if (!argp3) {
57775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57776     return 0;
57777   }
57778   arg3 = *argp3;
57779   {
57780     try {
57781       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57782     } catch (std::out_of_range& e) {
57783       {
57784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57785       };
57786     } catch (std::exception& e) {
57787       {
57788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57789       };
57790     } catch (Dali::DaliException e) {
57791       {
57792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57793       };
57794     } catch (...) {
57795       {
57796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57797       };
57798     }
57799   }
57800
57801   jresult = new Dali::Animation((const Dali::Animation &)result);
57802
57803   //argout typemap for const std::string&
57804
57805   return jresult;
57806 }
57807
57808
57809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57810   void * jresult ;
57811   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57812   std::string *arg2 = 0 ;
57813   Dali::Property::Map *arg3 = 0 ;
57814   Dali::Actor arg4 ;
57815   Dali::Actor *argp4 ;
57816   Dali::Animation result;
57817
57818   arg1 = (Dali::Toolkit::Builder *)jarg1;
57819   if (!jarg2) {
57820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57821     return 0;
57822   }
57823   std::string arg2_str(jarg2);
57824   arg2 = &arg2_str;
57825   arg3 = (Dali::Property::Map *)jarg3;
57826   if (!arg3) {
57827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57828     return 0;
57829   }
57830   argp4 = (Dali::Actor *)jarg4;
57831   if (!argp4) {
57832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57833     return 0;
57834   }
57835   arg4 = *argp4;
57836   {
57837     try {
57838       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57839     } catch (std::out_of_range& e) {
57840       {
57841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57842       };
57843     } catch (std::exception& e) {
57844       {
57845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57846       };
57847     } catch (Dali::DaliException e) {
57848       {
57849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57850       };
57851     } catch (...) {
57852       {
57853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57854       };
57855     }
57856   }
57857
57858   jresult = new Dali::Animation((const Dali::Animation &)result);
57859
57860   //argout typemap for const std::string&
57861
57862   return jresult;
57863 }
57864
57865
57866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
57867   void * jresult ;
57868   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57869   std::string *arg2 = 0 ;
57870   Dali::BaseHandle result;
57871
57872   arg1 = (Dali::Toolkit::Builder *)jarg1;
57873   if (!jarg2) {
57874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57875     return 0;
57876   }
57877   std::string arg2_str(jarg2);
57878   arg2 = &arg2_str;
57879   {
57880     try {
57881       result = (arg1)->Create((std::string const &)*arg2);
57882     } catch (std::out_of_range& e) {
57883       {
57884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57885       };
57886     } catch (std::exception& e) {
57887       {
57888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57889       };
57890     } catch (Dali::DaliException e) {
57891       {
57892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57893       };
57894     } catch (...) {
57895       {
57896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57897       };
57898     }
57899   }
57900
57901   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57902
57903   //argout typemap for const std::string&
57904
57905   return jresult;
57906 }
57907
57908
57909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57910   void * jresult ;
57911   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57912   std::string *arg2 = 0 ;
57913   Dali::Property::Map *arg3 = 0 ;
57914   Dali::BaseHandle result;
57915
57916   arg1 = (Dali::Toolkit::Builder *)jarg1;
57917   if (!jarg2) {
57918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57919     return 0;
57920   }
57921   std::string arg2_str(jarg2);
57922   arg2 = &arg2_str;
57923   arg3 = (Dali::Property::Map *)jarg3;
57924   if (!arg3) {
57925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57926     return 0;
57927   }
57928   {
57929     try {
57930       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57931     } catch (std::out_of_range& e) {
57932       {
57933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57934       };
57935     } catch (std::exception& e) {
57936       {
57937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57938       };
57939     } catch (Dali::DaliException e) {
57940       {
57941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57942       };
57943     } catch (...) {
57944       {
57945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57946       };
57947     }
57948   }
57949
57950   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57951
57952   //argout typemap for const std::string&
57953
57954   return jresult;
57955 }
57956
57957
57958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
57959   void * jresult ;
57960   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57961   std::string *arg2 = 0 ;
57962   Dali::BaseHandle result;
57963
57964   arg1 = (Dali::Toolkit::Builder *)jarg1;
57965   if (!jarg2) {
57966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57967     return 0;
57968   }
57969   std::string arg2_str(jarg2);
57970   arg2 = &arg2_str;
57971   {
57972     try {
57973       result = (arg1)->CreateFromJson((std::string const &)*arg2);
57974     } catch (std::out_of_range& e) {
57975       {
57976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57977       };
57978     } catch (std::exception& e) {
57979       {
57980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57981       };
57982     } catch (Dali::DaliException e) {
57983       {
57984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57985       };
57986     } catch (...) {
57987       {
57988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57989       };
57990     }
57991   }
57992
57993   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57994
57995   //argout typemap for const std::string&
57996
57997   return jresult;
57998 }
57999
58000
58001 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58002   unsigned int jresult ;
58003   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58004   std::string *arg2 = 0 ;
58005   Dali::Handle *arg3 = 0 ;
58006   bool result;
58007
58008   arg1 = (Dali::Toolkit::Builder *)jarg1;
58009   if (!jarg2) {
58010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58011     return 0;
58012   }
58013   std::string arg2_str(jarg2);
58014   arg2 = &arg2_str;
58015   arg3 = (Dali::Handle *)jarg3;
58016   if (!arg3) {
58017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58018     return 0;
58019   }
58020   {
58021     try {
58022       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58023     } catch (std::out_of_range& e) {
58024       {
58025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58026       };
58027     } catch (std::exception& e) {
58028       {
58029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58030       };
58031     } catch (Dali::DaliException e) {
58032       {
58033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58034       };
58035     } catch (...) {
58036       {
58037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58038       };
58039     }
58040   }
58041
58042   jresult = result;
58043
58044   //argout typemap for const std::string&
58045
58046   return jresult;
58047 }
58048
58049
58050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
58051   unsigned int jresult ;
58052   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58053   Dali::Handle *arg2 = 0 ;
58054   std::string *arg3 = 0 ;
58055   bool result;
58056
58057   arg1 = (Dali::Toolkit::Builder *)jarg1;
58058   arg2 = (Dali::Handle *)jarg2;
58059   if (!arg2) {
58060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58061     return 0;
58062   }
58063   if (!jarg3) {
58064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58065     return 0;
58066   }
58067   std::string arg3_str(jarg3);
58068   arg3 = &arg3_str;
58069   {
58070     try {
58071       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
58072     } catch (std::out_of_range& e) {
58073       {
58074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58075       };
58076     } catch (std::exception& e) {
58077       {
58078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58079       };
58080     } catch (Dali::DaliException e) {
58081       {
58082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58083       };
58084     } catch (...) {
58085       {
58086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58087       };
58088     }
58089   }
58090
58091   jresult = result;
58092
58093   //argout typemap for const std::string&
58094
58095   return jresult;
58096 }
58097
58098
58099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
58100   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58101   Dali::Actor arg2 ;
58102   Dali::Actor *argp2 ;
58103
58104   arg1 = (Dali::Toolkit::Builder *)jarg1;
58105   argp2 = (Dali::Actor *)jarg2;
58106   if (!argp2) {
58107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58108     return ;
58109   }
58110   arg2 = *argp2;
58111   {
58112     try {
58113       (arg1)->AddActors(arg2);
58114     } catch (std::out_of_range& e) {
58115       {
58116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58117       };
58118     } catch (std::exception& e) {
58119       {
58120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58121       };
58122     } catch (Dali::DaliException e) {
58123       {
58124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58125       };
58126     } catch (...) {
58127       {
58128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58129       };
58130     }
58131   }
58132
58133 }
58134
58135
58136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58137   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58138   std::string *arg2 = 0 ;
58139   Dali::Actor arg3 ;
58140   Dali::Actor *argp3 ;
58141
58142   arg1 = (Dali::Toolkit::Builder *)jarg1;
58143   if (!jarg2) {
58144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58145     return ;
58146   }
58147   std::string arg2_str(jarg2);
58148   arg2 = &arg2_str;
58149   argp3 = (Dali::Actor *)jarg3;
58150   if (!argp3) {
58151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58152     return ;
58153   }
58154   arg3 = *argp3;
58155   {
58156     try {
58157       (arg1)->AddActors((std::string const &)*arg2,arg3);
58158     } catch (std::out_of_range& e) {
58159       {
58160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58161       };
58162     } catch (std::exception& e) {
58163       {
58164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58165       };
58166     } catch (Dali::DaliException e) {
58167       {
58168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58169       };
58170     } catch (...) {
58171       {
58172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58173       };
58174     }
58175   }
58176
58177
58178   //argout typemap for const std::string&
58179
58180 }
58181
58182
58183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
58184   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58185   std::string *arg2 = 0 ;
58186
58187   arg1 = (Dali::Toolkit::Builder *)jarg1;
58188   if (!jarg2) {
58189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58190     return ;
58191   }
58192   std::string arg2_str(jarg2);
58193   arg2 = &arg2_str;
58194   {
58195     try {
58196       (arg1)->CreateRenderTask((std::string const &)*arg2);
58197     } catch (std::out_of_range& e) {
58198       {
58199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58200       };
58201     } catch (std::exception& e) {
58202       {
58203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58204       };
58205     } catch (Dali::DaliException e) {
58206       {
58207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58208       };
58209     } catch (...) {
58210       {
58211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58212       };
58213     }
58214   }
58215
58216
58217   //argout typemap for const std::string&
58218
58219 }
58220
58221
58222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58223   void * jresult ;
58224   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58225   std::string *arg2 = 0 ;
58226   Dali::Path result;
58227
58228   arg1 = (Dali::Toolkit::Builder *)jarg1;
58229   if (!jarg2) {
58230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58231     return 0;
58232   }
58233   std::string arg2_str(jarg2);
58234   arg2 = &arg2_str;
58235   {
58236     try {
58237       result = (arg1)->GetPath((std::string const &)*arg2);
58238     } catch (std::out_of_range& e) {
58239       {
58240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58241       };
58242     } catch (std::exception& e) {
58243       {
58244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58245       };
58246     } catch (Dali::DaliException e) {
58247       {
58248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58249       };
58250     } catch (...) {
58251       {
58252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58253       };
58254     }
58255   }
58256
58257   jresult = new Dali::Path((const Dali::Path &)result);
58258
58259   //argout typemap for const std::string&
58260
58261   return jresult;
58262 }
58263
58264
58265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58266   void * jresult ;
58267   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58268   std::string *arg2 = 0 ;
58269   Dali::PathConstrainer result;
58270
58271   arg1 = (Dali::Toolkit::Builder *)jarg1;
58272   if (!jarg2) {
58273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58274     return 0;
58275   }
58276   std::string arg2_str(jarg2);
58277   arg2 = &arg2_str;
58278   {
58279     try {
58280       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58281     } catch (std::out_of_range& e) {
58282       {
58283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58284       };
58285     } catch (std::exception& e) {
58286       {
58287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58288       };
58289     } catch (Dali::DaliException e) {
58290       {
58291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58292       };
58293     } catch (...) {
58294       {
58295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58296       };
58297     }
58298   }
58299
58300   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58301
58302   //argout typemap for const std::string&
58303
58304   return jresult;
58305 }
58306
58307
58308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58309   void * jresult ;
58310   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58311   std::string *arg2 = 0 ;
58312   Dali::LinearConstrainer result;
58313
58314   arg1 = (Dali::Toolkit::Builder *)jarg1;
58315   if (!jarg2) {
58316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58317     return 0;
58318   }
58319   std::string arg2_str(jarg2);
58320   arg2 = &arg2_str;
58321   {
58322     try {
58323       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58324     } catch (std::out_of_range& e) {
58325       {
58326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58327       };
58328     } catch (std::exception& e) {
58329       {
58330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58331       };
58332     } catch (Dali::DaliException e) {
58333       {
58334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58335       };
58336     } catch (...) {
58337       {
58338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58339       };
58340     }
58341   }
58342
58343   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58344
58345   //argout typemap for const std::string&
58346
58347   return jresult;
58348 }
58349
58350
58351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58352   void * jresult ;
58353   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58354   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58355
58356   arg1 = (Dali::Toolkit::Builder *)jarg1;
58357   {
58358     try {
58359       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58360     } catch (std::out_of_range& e) {
58361       {
58362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58363       };
58364     } catch (std::exception& e) {
58365       {
58366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58367       };
58368     } catch (Dali::DaliException e) {
58369       {
58370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58371       };
58372     } catch (...) {
58373       {
58374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58375       };
58376     }
58377   }
58378
58379   jresult = (void *)result;
58380   return jresult;
58381 }
58382
58383
58384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58385   void * jresult ;
58386   Dali::Toolkit::TransitionData *result = 0 ;
58387
58388   {
58389     try {
58390       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58391     } catch (std::out_of_range& e) {
58392       {
58393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58394       };
58395     } catch (std::exception& e) {
58396       {
58397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58398       };
58399     } catch (Dali::DaliException e) {
58400       {
58401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58402       };
58403     } catch (...) {
58404       {
58405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58406       };
58407     }
58408   }
58409
58410   jresult = (void *)result;
58411   return jresult;
58412 }
58413
58414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58415   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58416
58417   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58418   {
58419     try {
58420       delete arg1;
58421     } catch (std::out_of_range& e) {
58422       {
58423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58424       };
58425     } catch (std::exception& e) {
58426       {
58427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58428       };
58429     } catch (Dali::DaliException e) {
58430       {
58431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58432       };
58433     } catch (...) {
58434       {
58435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58436       };
58437     }
58438   }
58439
58440 }
58441
58442
58443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58444   void * jresult ;
58445   Dali::Property::Map *arg1 = 0 ;
58446   Dali::Toolkit::TransitionData result;
58447
58448   arg1 = (Dali::Property::Map *)jarg1;
58449   if (!arg1) {
58450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58451     return 0;
58452   }
58453   {
58454     try {
58455       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58456     } catch (std::out_of_range& e) {
58457       {
58458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58459       };
58460     } catch (std::exception& e) {
58461       {
58462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58463       };
58464     } catch (Dali::DaliException e) {
58465       {
58466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58467       };
58468     } catch (...) {
58469       {
58470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58471       };
58472     }
58473   }
58474
58475   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58476   return jresult;
58477 }
58478
58479
58480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58481   void * jresult ;
58482   Dali::Property::Array *arg1 = 0 ;
58483   Dali::Toolkit::TransitionData result;
58484
58485   arg1 = (Dali::Property::Array *)jarg1;
58486   if (!arg1) {
58487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58488     return 0;
58489   }
58490   {
58491     try {
58492       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58493     } catch (std::out_of_range& e) {
58494       {
58495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58496       };
58497     } catch (std::exception& e) {
58498       {
58499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58500       };
58501     } catch (Dali::DaliException e) {
58502       {
58503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58504       };
58505     } catch (...) {
58506       {
58507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58508       };
58509     }
58510   }
58511
58512   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58513   return jresult;
58514 }
58515
58516
58517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58518   void * jresult ;
58519   Dali::BaseHandle arg1 ;
58520   Dali::BaseHandle *argp1 ;
58521   Dali::Toolkit::TransitionData result;
58522
58523   argp1 = (Dali::BaseHandle *)jarg1;
58524   if (!argp1) {
58525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58526     return 0;
58527   }
58528   arg1 = *argp1;
58529   {
58530     try {
58531       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58532     } catch (std::out_of_range& e) {
58533       {
58534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58535       };
58536     } catch (std::exception& e) {
58537       {
58538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58539       };
58540     } catch (Dali::DaliException e) {
58541       {
58542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58543       };
58544     } catch (...) {
58545       {
58546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58547       };
58548     }
58549   }
58550
58551   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58552   return jresult;
58553 }
58554
58555
58556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58557   void * jresult ;
58558   Dali::Toolkit::TransitionData *arg1 = 0 ;
58559   Dali::Toolkit::TransitionData *result = 0 ;
58560
58561   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58562   if (!arg1) {
58563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58564     return 0;
58565   }
58566   {
58567     try {
58568       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58569     } catch (std::out_of_range& e) {
58570       {
58571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58572       };
58573     } catch (std::exception& e) {
58574       {
58575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58576       };
58577     } catch (Dali::DaliException e) {
58578       {
58579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58580       };
58581     } catch (...) {
58582       {
58583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58584       };
58585     }
58586   }
58587
58588   jresult = (void *)result;
58589   return jresult;
58590 }
58591
58592
58593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58594   void * jresult ;
58595   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58596   Dali::Toolkit::TransitionData *arg2 = 0 ;
58597   Dali::Toolkit::TransitionData *result = 0 ;
58598
58599   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58600   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58601   if (!arg2) {
58602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58603     return 0;
58604   }
58605   {
58606     try {
58607       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58608     } catch (std::out_of_range& e) {
58609       {
58610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58611       };
58612     } catch (std::exception& e) {
58613       {
58614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58615       };
58616     } catch (Dali::DaliException e) {
58617       {
58618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58619       };
58620     } catch (...) {
58621       {
58622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58623       };
58624     }
58625   }
58626
58627   jresult = (void *)result;
58628   return jresult;
58629 }
58630
58631
58632 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58633   unsigned long jresult ;
58634   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58635   size_t result;
58636
58637   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58638   {
58639     try {
58640       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58641     } catch (std::out_of_range& e) {
58642       {
58643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58644       };
58645     } catch (std::exception& e) {
58646       {
58647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58648       };
58649     } catch (Dali::DaliException e) {
58650       {
58651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58652       };
58653     } catch (...) {
58654       {
58655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58656       };
58657     }
58658   }
58659
58660   jresult = (unsigned long)result;
58661   return jresult;
58662 }
58663
58664
58665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58666   void * jresult ;
58667   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58668   size_t arg2 ;
58669   Dali::Property::Map result;
58670
58671   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58672   arg2 = (size_t)jarg2;
58673   {
58674     try {
58675       result = (arg1)->GetAnimatorAt(arg2);
58676     } catch (std::out_of_range& e) {
58677       {
58678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58679       };
58680     } catch (std::exception& e) {
58681       {
58682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58683       };
58684     } catch (Dali::DaliException e) {
58685       {
58686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58687       };
58688     } catch (...) {
58689       {
58690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58691       };
58692     }
58693   }
58694
58695   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58696   return jresult;
58697 }
58698
58699
58700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58701   int jresult ;
58702   int result;
58703
58704   {
58705     try {
58706       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58707     } catch (std::out_of_range& e) {
58708       {
58709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58710       };
58711     } catch (std::exception& e) {
58712       {
58713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58714       };
58715     } catch (Dali::DaliException e) {
58716       {
58717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58718       };
58719     } catch (...) {
58720       {
58721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58722       };
58723     }
58724   }
58725
58726   jresult = (int)result;
58727   return jresult;
58728 }
58729
58730
58731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58732   int jresult ;
58733   int result;
58734
58735   {
58736     try {
58737       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58738     } catch (std::out_of_range& e) {
58739       {
58740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58741       };
58742     } catch (std::exception& e) {
58743       {
58744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58745       };
58746     } catch (Dali::DaliException e) {
58747       {
58748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58749       };
58750     } catch (...) {
58751       {
58752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58753       };
58754     }
58755   }
58756
58757   jresult = (int)result;
58758   return jresult;
58759 }
58760
58761
58762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58763   int jresult ;
58764   int result;
58765
58766   {
58767     try {
58768       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58769     } catch (std::out_of_range& e) {
58770       {
58771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58772       };
58773     } catch (std::exception& e) {
58774       {
58775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58776       };
58777     } catch (Dali::DaliException e) {
58778       {
58779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58780       };
58781     } catch (...) {
58782       {
58783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58784       };
58785     }
58786   }
58787
58788   jresult = (int)result;
58789   return jresult;
58790 }
58791
58792
58793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58794   int jresult ;
58795   int result;
58796
58797   {
58798     try {
58799       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58800     } catch (std::out_of_range& e) {
58801       {
58802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58803       };
58804     } catch (std::exception& e) {
58805       {
58806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58807       };
58808     } catch (Dali::DaliException e) {
58809       {
58810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58811       };
58812     } catch (...) {
58813       {
58814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58815       };
58816     }
58817   }
58818
58819   jresult = (int)result;
58820   return jresult;
58821 }
58822
58823
58824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58825   int jresult ;
58826   int result;
58827
58828   {
58829     try {
58830       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58831     } catch (std::out_of_range& e) {
58832       {
58833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58834       };
58835     } catch (std::exception& e) {
58836       {
58837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58838       };
58839     } catch (Dali::DaliException e) {
58840       {
58841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58842       };
58843     } catch (...) {
58844       {
58845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58846       };
58847     }
58848   }
58849
58850   jresult = (int)result;
58851   return jresult;
58852 }
58853
58854
58855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58856   int jresult ;
58857   int result;
58858
58859   {
58860     try {
58861       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
58862     } catch (std::out_of_range& e) {
58863       {
58864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58865       };
58866     } catch (std::exception& e) {
58867       {
58868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58869       };
58870     } catch (Dali::DaliException e) {
58871       {
58872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58873       };
58874     } catch (...) {
58875       {
58876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58877       };
58878     }
58879   }
58880
58881   jresult = (int)result;
58882   return jresult;
58883 }
58884
58885
58886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
58887   int jresult ;
58888   int result;
58889
58890   {
58891     try {
58892       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
58893     } catch (std::out_of_range& e) {
58894       {
58895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58896       };
58897     } catch (std::exception& e) {
58898       {
58899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58900       };
58901     } catch (Dali::DaliException e) {
58902       {
58903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58904       };
58905     } catch (...) {
58906       {
58907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58908       };
58909     }
58910   }
58911
58912   jresult = (int)result;
58913   return jresult;
58914 }
58915
58916
58917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
58918   int jresult ;
58919   int result;
58920
58921   {
58922     try {
58923       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
58924     } catch (std::out_of_range& e) {
58925       {
58926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58927       };
58928     } catch (std::exception& e) {
58929       {
58930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58931       };
58932     } catch (Dali::DaliException e) {
58933       {
58934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58935       };
58936     } catch (...) {
58937       {
58938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58939       };
58940     }
58941   }
58942
58943   jresult = (int)result;
58944   return jresult;
58945 }
58946
58947
58948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
58949   int jresult ;
58950   int result;
58951
58952   {
58953     try {
58954       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
58955     } catch (std::out_of_range& e) {
58956       {
58957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58958       };
58959     } catch (std::exception& e) {
58960       {
58961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58962       };
58963     } catch (Dali::DaliException e) {
58964       {
58965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58966       };
58967     } catch (...) {
58968       {
58969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58970       };
58971     }
58972   }
58973
58974   jresult = (int)result;
58975   return jresult;
58976 }
58977
58978
58979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
58980   int jresult ;
58981   int result;
58982
58983   {
58984     try {
58985       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
58986     } catch (std::out_of_range& e) {
58987       {
58988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58989       };
58990     } catch (std::exception& e) {
58991       {
58992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58993       };
58994     } catch (Dali::DaliException e) {
58995       {
58996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58997       };
58998     } catch (...) {
58999       {
59000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59001       };
59002     }
59003   }
59004
59005   jresult = (int)result;
59006   return jresult;
59007 }
59008
59009
59010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
59011   int jresult ;
59012   int result;
59013
59014   {
59015     try {
59016       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
59017     } catch (std::out_of_range& e) {
59018       {
59019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59020       };
59021     } catch (std::exception& e) {
59022       {
59023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59024       };
59025     } catch (Dali::DaliException e) {
59026       {
59027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59028       };
59029     } catch (...) {
59030       {
59031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59032       };
59033     }
59034   }
59035
59036   jresult = (int)result;
59037   return jresult;
59038 }
59039
59040
59041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59042   int jresult ;
59043   int result;
59044
59045   {
59046     try {
59047       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59048     } catch (std::out_of_range& e) {
59049       {
59050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59051       };
59052     } catch (std::exception& e) {
59053       {
59054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59055       };
59056     } catch (Dali::DaliException e) {
59057       {
59058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59059       };
59060     } catch (...) {
59061       {
59062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59063       };
59064     }
59065   }
59066
59067   jresult = (int)result;
59068   return jresult;
59069 }
59070
59071
59072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59073   int jresult ;
59074   int result;
59075
59076   {
59077     try {
59078       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59079     } catch (std::out_of_range& e) {
59080       {
59081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59082       };
59083     } catch (std::exception& e) {
59084       {
59085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59086       };
59087     } catch (Dali::DaliException e) {
59088       {
59089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59090       };
59091     } catch (...) {
59092       {
59093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59094       };
59095     }
59096   }
59097
59098   jresult = (int)result;
59099   return jresult;
59100 }
59101
59102
59103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
59104   int jresult ;
59105   int result;
59106
59107   {
59108     try {
59109       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
59110     } catch (std::out_of_range& e) {
59111       {
59112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59113       };
59114     } catch (std::exception& e) {
59115       {
59116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59117       };
59118     } catch (Dali::DaliException e) {
59119       {
59120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59121       };
59122     } catch (...) {
59123       {
59124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59125       };
59126     }
59127   }
59128
59129   jresult = (int)result;
59130   return jresult;
59131 }
59132
59133
59134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59135   void * jresult ;
59136   Dali::Toolkit::Control result;
59137
59138   {
59139     try {
59140       result = Dali::Toolkit::Internal::Control::New();
59141     } catch (std::out_of_range& e) {
59142       {
59143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59144       };
59145     } catch (std::exception& e) {
59146       {
59147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59148       };
59149     } catch (Dali::DaliException e) {
59150       {
59151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59152       };
59153     } catch (...) {
59154       {
59155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59156       };
59157     }
59158   }
59159
59160   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59161   return jresult;
59162 }
59163
59164
59165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59166   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59167   std::string *arg2 = 0 ;
59168
59169   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59170   if (!jarg2) {
59171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59172     return ;
59173   }
59174   std::string arg2_str(jarg2);
59175   arg2 = &arg2_str;
59176   {
59177     try {
59178       (arg1)->SetStyleName((std::string const &)*arg2);
59179     } catch (std::out_of_range& e) {
59180       {
59181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59182       };
59183     } catch (std::exception& e) {
59184       {
59185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59186       };
59187     } catch (Dali::DaliException e) {
59188       {
59189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59190       };
59191     } catch (...) {
59192       {
59193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59194       };
59195     }
59196   }
59197
59198
59199   //argout typemap for const std::string&
59200
59201 }
59202
59203
59204 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59205   char * jresult ;
59206   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59207   std::string *result = 0 ;
59208
59209   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59210   {
59211     try {
59212       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59213     } catch (std::out_of_range& e) {
59214       {
59215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59216       };
59217     } catch (std::exception& e) {
59218       {
59219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59220       };
59221     } catch (Dali::DaliException e) {
59222       {
59223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59224       };
59225     } catch (...) {
59226       {
59227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59228       };
59229     }
59230   }
59231
59232   jresult = SWIG_csharp_string_callback(result->c_str());
59233   return jresult;
59234 }
59235
59236
59237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59238   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59239   Dali::Vector4 *arg2 = 0 ;
59240
59241   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59242   arg2 = (Dali::Vector4 *)jarg2;
59243   if (!arg2) {
59244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59245     return ;
59246   }
59247   {
59248     try {
59249       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59250     } catch (std::out_of_range& e) {
59251       {
59252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59253       };
59254     } catch (std::exception& e) {
59255       {
59256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59257       };
59258     } catch (Dali::DaliException e) {
59259       {
59260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59261       };
59262     } catch (...) {
59263       {
59264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59265       };
59266     }
59267   }
59268
59269 }
59270
59271
59272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
59273   void * jresult ;
59274   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
59275   Dali::Vector4 result;
59276
59277   arg1 = (Dali::Handle *)jarg1;
59278   {
59279     try {
59280       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
59281       if (resultMap)
59282       {
59283         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
59284         if(type && type->Get<int>() == Visual::COLOR )
59285         {
59286           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
59287           if (value)
59288           {
59289             result = value->Get<Vector4>();
59290           }
59291         }
59292       }
59293     } catch (std::out_of_range& e) {
59294       {
59295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59296       };
59297     } catch (std::exception& e) {
59298       {
59299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59300       };
59301     } catch (Dali::DaliException e) {
59302       {
59303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59304       };
59305     } catch (...) {
59306       {
59307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59308       };
59309     }
59310   }
59311
59312   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59313   return jresult;
59314 }
59315
59316
59317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59318   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59319   Dali::Property::Map *arg2 = 0 ;
59320
59321   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59322   arg2 = (Dali::Property::Map *)jarg2;
59323   if (!arg2) {
59324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59325     return ;
59326   }
59327   {
59328     try {
59329       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59330     } catch (std::out_of_range& e) {
59331       {
59332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59333       };
59334     } catch (std::exception& e) {
59335       {
59336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59337       };
59338     } catch (Dali::DaliException e) {
59339       {
59340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59341       };
59342     } catch (...) {
59343       {
59344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59345       };
59346     }
59347   }
59348
59349 }
59350
59351
59352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59353   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59354
59355   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59356   {
59357     try {
59358       (arg1)->ClearBackground();
59359     } catch (std::out_of_range& e) {
59360       {
59361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59362       };
59363     } catch (std::exception& e) {
59364       {
59365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59366       };
59367     } catch (Dali::DaliException e) {
59368       {
59369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59370       };
59371     } catch (...) {
59372       {
59373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59374       };
59375     }
59376   }
59377
59378 }
59379
59380
59381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59382   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59383   Dali::Gesture::Type arg2 ;
59384
59385   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59386   arg2 = (Dali::Gesture::Type)jarg2;
59387   {
59388     try {
59389       (arg1)->EnableGestureDetection(arg2);
59390     } catch (std::out_of_range& e) {
59391       {
59392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59393       };
59394     } catch (std::exception& e) {
59395       {
59396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59397       };
59398     } catch (Dali::DaliException e) {
59399       {
59400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59401       };
59402     } catch (...) {
59403       {
59404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59405       };
59406     }
59407   }
59408
59409 }
59410
59411
59412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59413   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59414   Dali::Gesture::Type arg2 ;
59415
59416   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59417   arg2 = (Dali::Gesture::Type)jarg2;
59418   {
59419     try {
59420       (arg1)->DisableGestureDetection(arg2);
59421     } catch (std::out_of_range& e) {
59422       {
59423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59424       };
59425     } catch (std::exception& e) {
59426       {
59427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59428       };
59429     } catch (Dali::DaliException e) {
59430       {
59431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59432       };
59433     } catch (...) {
59434       {
59435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59436       };
59437     }
59438   }
59439
59440 }
59441
59442
59443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59444   void * jresult ;
59445   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59446   Dali::PinchGestureDetector result;
59447
59448   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59449   {
59450     try {
59451       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59452     } catch (std::out_of_range& e) {
59453       {
59454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59455       };
59456     } catch (std::exception& e) {
59457       {
59458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59459       };
59460     } catch (Dali::DaliException e) {
59461       {
59462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59463       };
59464     } catch (...) {
59465       {
59466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59467       };
59468     }
59469   }
59470
59471   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59472   return jresult;
59473 }
59474
59475
59476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59477   void * jresult ;
59478   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59479   Dali::PanGestureDetector result;
59480
59481   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59482   {
59483     try {
59484       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59485     } catch (std::out_of_range& e) {
59486       {
59487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59488       };
59489     } catch (std::exception& e) {
59490       {
59491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59492       };
59493     } catch (Dali::DaliException e) {
59494       {
59495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59496       };
59497     } catch (...) {
59498       {
59499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59500       };
59501     }
59502   }
59503
59504   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59505   return jresult;
59506 }
59507
59508
59509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59510   void * jresult ;
59511   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59512   Dali::TapGestureDetector result;
59513
59514   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59515   {
59516     try {
59517       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59518     } catch (std::out_of_range& e) {
59519       {
59520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59521       };
59522     } catch (std::exception& e) {
59523       {
59524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59525       };
59526     } catch (Dali::DaliException e) {
59527       {
59528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59529       };
59530     } catch (...) {
59531       {
59532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59533       };
59534     }
59535   }
59536
59537   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59538   return jresult;
59539 }
59540
59541
59542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59543   void * jresult ;
59544   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59545   Dali::LongPressGestureDetector result;
59546
59547   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59548   {
59549     try {
59550       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59551     } catch (std::out_of_range& e) {
59552       {
59553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59554       };
59555     } catch (std::exception& e) {
59556       {
59557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59558       };
59559     } catch (Dali::DaliException e) {
59560       {
59561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59562       };
59563     } catch (...) {
59564       {
59565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59566       };
59567     }
59568   }
59569
59570   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59571   return jresult;
59572 }
59573
59574
59575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59576   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59577   bool arg2 ;
59578
59579   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59580   arg2 = jarg2 ? true : false;
59581   {
59582     try {
59583       (arg1)->SetKeyboardNavigationSupport(arg2);
59584     } catch (std::out_of_range& e) {
59585       {
59586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59587       };
59588     } catch (std::exception& e) {
59589       {
59590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59591       };
59592     } catch (Dali::DaliException e) {
59593       {
59594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59595       };
59596     } catch (...) {
59597       {
59598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59599       };
59600     }
59601   }
59602
59603 }
59604
59605
59606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59607   unsigned int jresult ;
59608   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59609   bool result;
59610
59611   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59612   {
59613     try {
59614       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59615     } catch (std::out_of_range& e) {
59616       {
59617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59618       };
59619     } catch (std::exception& e) {
59620       {
59621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59622       };
59623     } catch (Dali::DaliException e) {
59624       {
59625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59626       };
59627     } catch (...) {
59628       {
59629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59630       };
59631     }
59632   }
59633
59634   jresult = result;
59635   return jresult;
59636 }
59637
59638
59639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59640   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59641
59642   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59643   {
59644     try {
59645       (arg1)->SetKeyInputFocus();
59646     } catch (std::out_of_range& e) {
59647       {
59648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59649       };
59650     } catch (std::exception& e) {
59651       {
59652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59653       };
59654     } catch (Dali::DaliException e) {
59655       {
59656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59657       };
59658     } catch (...) {
59659       {
59660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59661       };
59662     }
59663   }
59664
59665 }
59666
59667
59668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
59669   unsigned int jresult ;
59670   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59671   bool result;
59672
59673   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59674   {
59675     try {
59676       result = (bool)(arg1)->HasKeyInputFocus();
59677     } catch (std::out_of_range& e) {
59678       {
59679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59680       };
59681     } catch (std::exception& e) {
59682       {
59683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59684       };
59685     } catch (Dali::DaliException e) {
59686       {
59687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59688       };
59689     } catch (...) {
59690       {
59691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59692       };
59693     }
59694   }
59695
59696   jresult = result;
59697   return jresult;
59698 }
59699
59700
59701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
59702   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59703
59704   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59705   {
59706     try {
59707       (arg1)->ClearKeyInputFocus();
59708     } catch (std::out_of_range& e) {
59709       {
59710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59711       };
59712     } catch (std::exception& e) {
59713       {
59714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59715       };
59716     } catch (Dali::DaliException e) {
59717       {
59718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59719       };
59720     } catch (...) {
59721       {
59722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59723       };
59724     }
59725   }
59726
59727 }
59728
59729
59730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
59731   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59732   bool arg2 ;
59733
59734   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59735   arg2 = jarg2 ? true : false;
59736   {
59737     try {
59738       (arg1)->SetAsKeyboardFocusGroup(arg2);
59739     } catch (std::out_of_range& e) {
59740       {
59741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59742       };
59743     } catch (std::exception& e) {
59744       {
59745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59746       };
59747     } catch (Dali::DaliException e) {
59748       {
59749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59750       };
59751     } catch (...) {
59752       {
59753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59754       };
59755     }
59756   }
59757
59758 }
59759
59760
59761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
59762   unsigned int jresult ;
59763   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59764   bool result;
59765
59766   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59767   {
59768     try {
59769       result = (bool)(arg1)->IsKeyboardFocusGroup();
59770     } catch (std::out_of_range& e) {
59771       {
59772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59773       };
59774     } catch (std::exception& e) {
59775       {
59776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59777       };
59778     } catch (Dali::DaliException e) {
59779       {
59780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59781       };
59782     } catch (...) {
59783       {
59784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59785       };
59786     }
59787   }
59788
59789   jresult = result;
59790   return jresult;
59791 }
59792
59793
59794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59795   void * jresult ;
59796   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59797   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59798
59799   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59800   {
59801     try {
59802       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59803     } catch (std::out_of_range& e) {
59804       {
59805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59806       };
59807     } catch (std::exception& e) {
59808       {
59809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59810       };
59811     } catch (Dali::DaliException e) {
59812       {
59813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59814       };
59815     } catch (...) {
59816       {
59817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59818       };
59819     }
59820   }
59821
59822   jresult = (void *)result;
59823   return jresult;
59824 }
59825
59826
59827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59828   void * jresult ;
59829   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59830   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59831
59832   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59833   {
59834     try {
59835       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59836     } catch (std::out_of_range& e) {
59837       {
59838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59839       };
59840     } catch (std::exception& e) {
59841       {
59842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59843       };
59844     } catch (Dali::DaliException e) {
59845       {
59846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59847       };
59848     } catch (...) {
59849       {
59850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59851       };
59852     }
59853   }
59854
59855   jresult = (void *)result;
59856   return jresult;
59857 }
59858
59859
59860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59861   void * jresult ;
59862   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59863   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59864
59865   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59866   {
59867     try {
59868       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59869     } catch (std::out_of_range& e) {
59870       {
59871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59872       };
59873     } catch (std::exception& e) {
59874       {
59875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59876       };
59877     } catch (Dali::DaliException e) {
59878       {
59879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59880       };
59881     } catch (...) {
59882       {
59883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59884       };
59885     }
59886   }
59887
59888   jresult = (void *)result;
59889   return jresult;
59890 }
59891
59892
59893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
59894   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59895   int arg2 ;
59896   SwigDirector_ViewImpl *darg = 0;
59897
59898   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59899   arg2 = (int)jarg2;
59900   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59901   if(!darg) {
59902     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59903     return;
59904   }
59905   {
59906     try {
59907       if(darg) {
59908         (darg)->OnSceneConnection(arg2);
59909       }
59910     } catch (std::out_of_range& e) {
59911       {
59912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59913       };
59914     } catch (std::exception& e) {
59915       {
59916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59917       };
59918     } catch (Dali::DaliException e) {
59919       {
59920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59921       };
59922     } catch (...) {
59923       {
59924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59925       };
59926     }
59927   }
59928
59929 }
59930
59931
59932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
59933   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59934   int arg2 ;
59935   SwigDirector_ViewImpl *darg = 0;
59936
59937   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59938   arg2 = (int)jarg2;
59939   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59940   if(!darg) {
59941     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59942     return;
59943   }
59944   {
59945     try {
59946       if(darg) {
59947         (darg)->OnSceneConnectionSwigPublic(arg2);
59948       }
59949     } catch (std::out_of_range& e) {
59950       {
59951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59952       };
59953     } catch (std::exception& e) {
59954       {
59955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59956       };
59957     } catch (Dali::DaliException e) {
59958       {
59959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59960       };
59961     } catch (...) {
59962       {
59963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59964       };
59965     }
59966   }
59967
59968 }
59969
59970
59971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
59972   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59973   SwigDirector_ViewImpl *darg = 0;
59974
59975   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59976   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59977   if(!darg) {
59978     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59979     return;
59980   }
59981   {
59982     try {
59983       if(darg) {
59984         (darg)->OnSceneDisconnection();
59985       }
59986     } catch (std::out_of_range& e) {
59987       {
59988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59989       };
59990     } catch (std::exception& e) {
59991       {
59992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59993       };
59994     } catch (Dali::DaliException e) {
59995       {
59996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59997       };
59998     } catch (...) {
59999       {
60000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60001       };
60002     }
60003   }
60004
60005 }
60006
60007
60008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
60009   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60010   SwigDirector_ViewImpl *darg = 0;
60011
60012   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60013   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60014   if(!darg) {
60015     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60016     return;
60017   }
60018   {
60019     try {
60020       if(darg) {
60021         (darg)->OnSceneDisconnectionSwigPublic();
60022       }
60023     } catch (std::out_of_range& e) {
60024       {
60025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60026       };
60027     } catch (std::exception& e) {
60028       {
60029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60030       };
60031     } catch (Dali::DaliException e) {
60032       {
60033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60034       };
60035     } catch (...) {
60036       {
60037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60038       };
60039     }
60040   }
60041
60042 }
60043
60044
60045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60046   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60047   Dali::Actor *arg2 = 0 ;
60048   SwigDirector_ViewImpl *darg = 0;
60049
60050   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60051   arg2 = (Dali::Actor *)jarg2;
60052   if (!arg2) {
60053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60054     return ;
60055   }
60056   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60057   if(!darg) {
60058     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60059     return;
60060   }
60061   {
60062     try {
60063       if(darg) {
60064         (darg)->OnChildAdd(*arg2);
60065       }
60066     } catch (std::out_of_range& e) {
60067       {
60068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60069       };
60070     } catch (std::exception& e) {
60071       {
60072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60073       };
60074     } catch (Dali::DaliException e) {
60075       {
60076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60077       };
60078     } catch (...) {
60079       {
60080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60081       };
60082     }
60083   }
60084
60085 }
60086
60087
60088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60089   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60090   Dali::Actor *arg2 = 0 ;
60091   SwigDirector_ViewImpl *darg = 0;
60092
60093   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60094   arg2 = (Dali::Actor *)jarg2;
60095   if (!arg2) {
60096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60097     return ;
60098   }
60099   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60100   if(!darg) {
60101     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60102     return;
60103   }
60104   {
60105     try {
60106       if(darg) {
60107           (darg)->OnChildAddSwigPublic(*arg2);
60108       }
60109     } catch (std::out_of_range& e) {
60110       {
60111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60112       };
60113     } catch (std::exception& e) {
60114       {
60115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60116       };
60117     } catch (Dali::DaliException e) {
60118       {
60119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60120       };
60121     } catch (...) {
60122       {
60123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60124       };
60125     }
60126   }
60127
60128 }
60129
60130
60131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60132   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60133   Dali::Actor *arg2 = 0 ;
60134   SwigDirector_ViewImpl *darg = 0;
60135
60136   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60137   arg2 = (Dali::Actor *)jarg2;
60138   if (!arg2) {
60139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60140     return ;
60141   }
60142   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60143   if(!darg) {
60144     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60145     return;
60146   }
60147   {
60148     try {
60149       if(darg) {
60150         (darg)->OnChildRemove(*arg2);
60151       }
60152     } catch (std::out_of_range& e) {
60153       {
60154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60155       };
60156     } catch (std::exception& e) {
60157       {
60158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60159       };
60160     } catch (Dali::DaliException e) {
60161       {
60162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60163       };
60164     } catch (...) {
60165       {
60166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60167       };
60168     }
60169   }
60170
60171 }
60172
60173
60174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60175   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60176   Dali::Actor *arg2 = 0 ;
60177   SwigDirector_ViewImpl *darg = 0;
60178
60179   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60180   arg2 = (Dali::Actor *)jarg2;
60181   if (!arg2) {
60182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60183     return ;
60184   }
60185   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60186   if(!darg) {
60187     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60188     return;
60189   }
60190   {
60191     try {
60192       if(darg) {
60193         (darg)->OnChildRemoveSwigPublic(*arg2);
60194       }
60195     } catch (std::out_of_range& e) {
60196       {
60197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60198       };
60199     } catch (std::exception& e) {
60200       {
60201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60202       };
60203     } catch (Dali::DaliException e) {
60204       {
60205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60206       };
60207     } catch (...) {
60208       {
60209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60210       };
60211     }
60212   }
60213
60214 }
60215
60216
60217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60218   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60219   Dali::Property::Index arg2 ;
60220   Dali::Property::Value arg3 ;
60221   Dali::Property::Value *argp3 ;
60222   SwigDirector_ViewImpl *darg = 0;
60223
60224   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60225   arg2 = (Dali::Property::Index)jarg2;
60226   argp3 = (Dali::Property::Value *)jarg3;
60227   if (!argp3) {
60228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60229     return ;
60230   }
60231   arg3 = *argp3;
60232   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60233   if (!darg) {
60234     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60235     return;
60236   }
60237   {
60238     try {
60239       (darg)->OnPropertySet(arg2,arg3);
60240     } catch (std::out_of_range& e) {
60241       {
60242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60243       };
60244     } catch (std::exception& e) {
60245       {
60246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60247       };
60248     } catch (Dali::DaliException e) {
60249       {
60250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60251       };
60252     } catch (...) {
60253       {
60254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60255       };
60256     }
60257   }
60258
60259 }
60260
60261
60262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60263   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60264   Dali::Property::Index arg2 ;
60265   Dali::Property::Value arg3 ;
60266   Dali::Property::Value *argp3 ;
60267   SwigDirector_ViewImpl *darg = 0;
60268
60269   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60270   arg2 = (Dali::Property::Index)jarg2;
60271   argp3 = (Dali::Property::Value *)jarg3;
60272   if (!argp3) {
60273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60274     return ;
60275   }
60276   arg3 = *argp3;
60277   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60278   if (!darg) {
60279     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60280     return;
60281   }
60282   {
60283     try {
60284       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60285     } catch (std::out_of_range& e) {
60286       {
60287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60288       };
60289     } catch (std::exception& e) {
60290       {
60291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60292       };
60293     } catch (Dali::DaliException e) {
60294       {
60295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60296       };
60297     } catch (...) {
60298       {
60299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60300       };
60301     }
60302   }
60303
60304 }
60305
60306
60307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60308   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60309   Dali::Vector3 *arg2 = 0 ;
60310   SwigDirector_ViewImpl *darg = 0;
60311
60312   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60313   arg2 = (Dali::Vector3 *)jarg2;
60314   if (!arg2) {
60315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60316     return ;
60317   }
60318   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60319   if (!darg) {
60320     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60321     return;
60322   }
60323   {
60324     try {
60325       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60326     } catch (std::out_of_range& e) {
60327       {
60328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60329       };
60330     } catch (std::exception& e) {
60331       {
60332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60333       };
60334     } catch (Dali::DaliException e) {
60335       {
60336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60337       };
60338     } catch (...) {
60339       {
60340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60341       };
60342     }
60343   }
60344
60345 }
60346
60347
60348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60349   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60350   Dali::Vector3 *arg2 = 0 ;
60351   SwigDirector_ViewImpl *darg = 0;
60352
60353   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60354   arg2 = (Dali::Vector3 *)jarg2;
60355   if (!arg2) {
60356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60357     return ;
60358   }
60359   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60360   if (!darg) {
60361     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60362     return;
60363   }
60364   {
60365     try {
60366       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60367     } catch (std::out_of_range& e) {
60368       {
60369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60370       };
60371     } catch (std::exception& e) {
60372       {
60373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60374       };
60375     } catch (Dali::DaliException e) {
60376       {
60377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60378       };
60379     } catch (...) {
60380       {
60381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60382       };
60383     }
60384   }
60385
60386 }
60387
60388
60389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60390   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60391   Dali::Animation *arg2 = 0 ;
60392   Dali::Vector3 *arg3 = 0 ;
60393   SwigDirector_ViewImpl *darg = 0;
60394
60395   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60396   arg2 = (Dali::Animation *)jarg2;
60397   if (!arg2) {
60398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60399     return ;
60400   }
60401   arg3 = (Dali::Vector3 *)jarg3;
60402   if (!arg3) {
60403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60404     return ;
60405   }
60406   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60407   if (!darg) {
60408     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60409     return;
60410   }
60411   {
60412     try {
60413       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60414     } catch (std::out_of_range& e) {
60415       {
60416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60417       };
60418     } catch (std::exception& e) {
60419       {
60420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60421       };
60422     } catch (Dali::DaliException e) {
60423       {
60424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60425       };
60426     } catch (...) {
60427       {
60428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60429       };
60430     }
60431   }
60432
60433 }
60434
60435
60436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60437   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60438   Dali::Animation *arg2 = 0 ;
60439   Dali::Vector3 *arg3 = 0 ;
60440   SwigDirector_ViewImpl *darg = 0;
60441
60442   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60443   arg2 = (Dali::Animation *)jarg2;
60444   if (!arg2) {
60445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60446     return ;
60447   }
60448   arg3 = (Dali::Vector3 *)jarg3;
60449   if (!arg3) {
60450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60451     return ;
60452   }
60453   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60454   if (!darg) {
60455     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60456     return;
60457   }
60458   {
60459     try {
60460       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60461     } catch (std::out_of_range& e) {
60462       {
60463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60464       };
60465     } catch (std::exception& e) {
60466       {
60467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60468       };
60469     } catch (Dali::DaliException e) {
60470       {
60471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60472       };
60473     } catch (...) {
60474       {
60475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60476       };
60477     }
60478   }
60479 }
60480
60481
60482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60483   unsigned int jresult ;
60484   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60485   Dali::HoverEvent *arg2 = 0 ;
60486   SwigDirector_ViewImpl *darg = 0;
60487   bool result;
60488
60489   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60490   arg2 = (Dali::HoverEvent *)jarg2;
60491   if (!arg2) {
60492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60493     return 0;
60494   }
60495   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60496   if (!darg) {
60497     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60498     return 0;
60499   }
60500   {
60501     try {
60502       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60503     } catch (std::out_of_range& e) {
60504       {
60505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60506       };
60507     } catch (std::exception& e) {
60508       {
60509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60510       };
60511     } catch (Dali::DaliException e) {
60512       {
60513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60514       };
60515     } catch (...) {
60516       {
60517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60518       };
60519     }
60520   }
60521
60522   jresult = result;
60523   return jresult;
60524 }
60525
60526
60527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60528   unsigned int jresult ;
60529   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60530   Dali::HoverEvent *arg2 = 0 ;
60531   SwigDirector_ViewImpl *darg = 0;
60532   bool result;
60533
60534   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60535   arg2 = (Dali::HoverEvent *)jarg2;
60536   if (!arg2) {
60537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60538     return 0;
60539   }
60540   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60541   if (!darg) {
60542     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60543     return 0;
60544   }
60545   {
60546     try {
60547       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60548     } catch (std::out_of_range& e) {
60549       {
60550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60551       };
60552     } catch (std::exception& e) {
60553       {
60554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60555       };
60556     } catch (Dali::DaliException e) {
60557       {
60558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60559       };
60560     } catch (...) {
60561       {
60562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60563       };
60564     }
60565   }
60566
60567   jresult = result;
60568   return jresult;
60569 }
60570
60571
60572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60573   unsigned int jresult ;
60574   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60575   Dali::KeyEvent *arg2 = 0 ;
60576   SwigDirector_ViewImpl *darg = 0;
60577   bool result;
60578
60579   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60580   arg2 = (Dali::KeyEvent *)jarg2;
60581   if (!arg2) {
60582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60583     return 0;
60584   }
60585   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60586   if (!darg) {
60587     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60588     return 0;
60589   }
60590   {
60591     try {
60592       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60593     } catch (std::out_of_range& e) {
60594       {
60595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60596       };
60597     } catch (std::exception& e) {
60598       {
60599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60600       };
60601     } catch (Dali::DaliException e) {
60602       {
60603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60604       };
60605     } catch (...) {
60606       {
60607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60608       };
60609     }
60610   }
60611
60612   jresult = result;
60613   return jresult;
60614 }
60615
60616
60617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60618   unsigned int jresult ;
60619   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60620   Dali::KeyEvent *arg2 = 0 ;
60621   SwigDirector_ViewImpl *darg = 0;
60622   bool result;
60623
60624   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60625   arg2 = (Dali::KeyEvent *)jarg2;
60626   if (!arg2) {
60627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60628     return 0;
60629   }
60630   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60631   if (!darg) {
60632     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60633     return 0;
60634   }
60635   {
60636     try {
60637       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60638     } catch (std::out_of_range& e) {
60639       {
60640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60641       };
60642     } catch (std::exception& e) {
60643       {
60644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60645       };
60646     } catch (Dali::DaliException e) {
60647       {
60648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60649       };
60650     } catch (...) {
60651       {
60652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60653       };
60654     }
60655   }
60656
60657   jresult = result;
60658   return jresult;
60659 }
60660
60661
60662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60663   unsigned int jresult ;
60664   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60665   Dali::WheelEvent *arg2 = 0 ;
60666   SwigDirector_ViewImpl *darg = 0;
60667   bool result;
60668
60669   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60670   arg2 = (Dali::WheelEvent *)jarg2;
60671   if (!arg2) {
60672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60673     return 0;
60674   }
60675   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60676   if (!darg) {
60677     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60678     return 0;
60679   }
60680   {
60681     try {
60682       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
60683     } catch (std::out_of_range& e) {
60684       {
60685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60686       };
60687     } catch (std::exception& e) {
60688       {
60689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60690       };
60691     } catch (Dali::DaliException e) {
60692       {
60693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60694       };
60695     } catch (...) {
60696       {
60697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60698       };
60699     }
60700   }
60701
60702   jresult = result;
60703   return jresult;
60704 }
60705
60706
60707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60708   unsigned int jresult ;
60709   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60710   Dali::WheelEvent *arg2 = 0 ;
60711   SwigDirector_ViewImpl *darg = 0;
60712   bool result;
60713
60714   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60715   arg2 = (Dali::WheelEvent *)jarg2;
60716   if (!arg2) {
60717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60718     return 0;
60719   }
60720   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60721   if (!darg) {
60722     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60723     return 0;
60724   }
60725   {
60726     try {
60727       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
60728     } catch (std::out_of_range& e) {
60729       {
60730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60731       };
60732     } catch (std::exception& e) {
60733       {
60734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60735       };
60736     } catch (Dali::DaliException e) {
60737       {
60738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60739       };
60740     } catch (...) {
60741       {
60742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60743       };
60744     }
60745   }
60746
60747   jresult = result;
60748   return jresult;
60749 }
60750
60751
60752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
60753   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60754   Dali::Vector2 *arg2 = 0 ;
60755   Dali::RelayoutContainer *arg3 = 0 ;
60756   SwigDirector_ViewImpl *darg = 0;
60757
60758   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60759   arg2 = (Dali::Vector2 *)jarg2;
60760   if (!arg2) {
60761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60762     return ;
60763   }
60764   arg3 = (Dali::RelayoutContainer *)jarg3;
60765   if (!arg3) {
60766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60767     return ;
60768   }
60769   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60770   if (!darg) {
60771     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60772     return;
60773   }
60774   {
60775     try {
60776       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
60777     } catch (std::out_of_range& e) {
60778       {
60779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60780       };
60781     } catch (std::exception& e) {
60782       {
60783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60784       };
60785     } catch (Dali::DaliException e) {
60786       {
60787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60788       };
60789     } catch (...) {
60790       {
60791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60792       };
60793     }
60794   }
60795
60796 }
60797
60798
60799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60800   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60801   Dali::Vector2 *arg2 = 0 ;
60802   Dali::RelayoutContainer *arg3 = 0 ;
60803   SwigDirector_ViewImpl *darg = 0;
60804
60805   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60806   arg2 = (Dali::Vector2 *)jarg2;
60807   if (!arg2) {
60808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60809     return ;
60810   }
60811   arg3 = (Dali::RelayoutContainer *)jarg3;
60812   if (!arg3) {
60813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60814     return ;
60815   }
60816   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60817   if (!darg) {
60818     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60819     return;
60820   }
60821   {
60822     try {
60823       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
60824     } catch (std::out_of_range& e) {
60825       {
60826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60827       };
60828     } catch (std::exception& e) {
60829       {
60830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60831       };
60832     } catch (Dali::DaliException e) {
60833       {
60834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60835       };
60836     } catch (...) {
60837       {
60838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60839       };
60840     }
60841   }
60842
60843 }
60844
60845
60846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
60847   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60848   Dali::ResizePolicy::Type arg2 ;
60849   Dali::Dimension::Type arg3 ;
60850   SwigDirector_ViewImpl *darg = 0;
60851
60852   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60853   arg2 = (Dali::ResizePolicy::Type)jarg2;
60854   arg3 = (Dali::Dimension::Type)jarg3;
60855   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60856   if (!darg) {
60857     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60858     return;
60859   }
60860   {
60861     try {
60862       (darg)->OnSetResizePolicy(arg2,arg3);
60863     } catch (std::out_of_range& e) {
60864       {
60865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60866       };
60867     } catch (std::exception& e) {
60868       {
60869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60870       };
60871     } catch (Dali::DaliException e) {
60872       {
60873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60874       };
60875     } catch (...) {
60876       {
60877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60878       };
60879     }
60880   }
60881
60882 }
60883
60884
60885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
60886   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60887   Dali::ResizePolicy::Type arg2 ;
60888   Dali::Dimension::Type arg3 ;
60889   SwigDirector_ViewImpl *darg = 0;
60890
60891   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60892   arg2 = (Dali::ResizePolicy::Type)jarg2;
60893   arg3 = (Dali::Dimension::Type)jarg3;
60894   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60895   if (!darg) {
60896     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60897     return;
60898   }
60899   {
60900     try {
60901       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
60902     } catch (std::out_of_range& e) {
60903       {
60904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60905       };
60906     } catch (std::exception& e) {
60907       {
60908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60909       };
60910     } catch (Dali::DaliException e) {
60911       {
60912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60913       };
60914     } catch (...) {
60915       {
60916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60917       };
60918     }
60919   }
60920
60921 }
60922
60923
60924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
60925   void * jresult ;
60926   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60927   SwigDirector_ViewImpl *darg = 0;
60928   Dali::Vector3 result;
60929
60930   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60931   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60932   if (!darg) {
60933     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60934     return 0;
60935   }
60936   {
60937     try {
60938       result = (darg)->GetNaturalSize();
60939     } catch (std::out_of_range& e) {
60940       {
60941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60942       };
60943     } catch (std::exception& e) {
60944       {
60945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60946       };
60947     } catch (Dali::DaliException e) {
60948       {
60949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60950       };
60951     } catch (...) {
60952       {
60953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60954       };
60955     }
60956   }
60957
60958   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60959   return jresult;
60960 }
60961
60962
60963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
60964   void * jresult ;
60965   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60966   SwigDirector_ViewImpl *darg = 0;
60967   Dali::Vector3 result;
60968
60969   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60970   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60971   if (!darg) {
60972     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60973     return 0;
60974   }
60975   {
60976     try {
60977       result = (darg)->GetNaturalSizeSwigPublic();
60978     } catch (std::out_of_range& e) {
60979       {
60980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60981       };
60982     } catch (std::exception& e) {
60983       {
60984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60985       };
60986     } catch (Dali::DaliException e) {
60987       {
60988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60989       };
60990     } catch (...) {
60991       {
60992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60993       };
60994     }
60995   }
60996
60997   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60998   return jresult;
60999 }
61000
61001
61002 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
61003   float jresult ;
61004   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61005   Dali::Actor *arg2 = 0 ;
61006   Dali::Dimension::Type arg3 ;
61007   SwigDirector_ViewImpl *darg = 0;
61008   float result;
61009
61010   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61011   arg2 = (Dali::Actor *)jarg2;
61012   if (!arg2) {
61013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61014     return 0;
61015   }
61016   arg3 = (Dali::Dimension::Type)jarg3;
61017   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61018   if (!darg) {
61019     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61020     return 0;
61021   }
61022   {
61023     try {
61024       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61025     } catch (std::out_of_range& e) {
61026       {
61027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61028       };
61029     } catch (std::exception& e) {
61030       {
61031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61032       };
61033     } catch (Dali::DaliException e) {
61034       {
61035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61036       };
61037     } catch (...) {
61038       {
61039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61040       };
61041     }
61042   }
61043
61044   jresult = result;
61045   return jresult;
61046 }
61047
61048
61049 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61050   float jresult ;
61051   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61052   Dali::Actor *arg2 = 0 ;
61053   Dali::Dimension::Type arg3 ;
61054   SwigDirector_ViewImpl *darg = 0;
61055   float result;
61056
61057   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61058   arg2 = (Dali::Actor *)jarg2;
61059   if (!arg2) {
61060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61061     return 0;
61062   }
61063   arg3 = (Dali::Dimension::Type)jarg3;
61064   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61065   if (!darg) {
61066     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61067     return 0;
61068   }
61069   {
61070     try {
61071       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61072     } catch (std::out_of_range& e) {
61073       {
61074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61075       };
61076     } catch (std::exception& e) {
61077       {
61078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61079       };
61080     } catch (Dali::DaliException e) {
61081       {
61082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61083       };
61084     } catch (...) {
61085       {
61086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61087       };
61088     }
61089   }
61090
61091   jresult = result;
61092   return jresult;
61093 }
61094
61095
61096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61097   float jresult ;
61098   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61099   float arg2 ;
61100   SwigDirector_ViewImpl *darg = 0;
61101   float result;
61102
61103   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61104   arg2 = (float)jarg2;
61105   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61106   if (!darg) {
61107     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61108     return 0;
61109   }
61110   {
61111     try {
61112       result = (float)(darg)->GetHeightForWidth(arg2);
61113     } catch (std::out_of_range& e) {
61114       {
61115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61116       };
61117     } catch (std::exception& e) {
61118       {
61119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61120       };
61121     } catch (Dali::DaliException e) {
61122       {
61123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61124       };
61125     } catch (...) {
61126       {
61127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61128       };
61129     }
61130   }
61131
61132   jresult = result;
61133   return jresult;
61134 }
61135
61136
61137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61138   float jresult ;
61139   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61140   float arg2 ;
61141   SwigDirector_ViewImpl *darg = 0;
61142   float result;
61143
61144   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61145   arg2 = (float)jarg2;
61146   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61147   if (!darg) {
61148     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61149     return 0;
61150   }
61151   {
61152     try {
61153       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61154     } catch (std::out_of_range& e) {
61155       {
61156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61157       };
61158     } catch (std::exception& e) {
61159       {
61160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61161       };
61162     } catch (Dali::DaliException e) {
61163       {
61164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61165       };
61166     } catch (...) {
61167       {
61168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61169       };
61170     }
61171   }
61172
61173   jresult = result;
61174   return jresult;
61175 }
61176
61177
61178 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61179   float jresult ;
61180   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61181   float arg2 ;
61182   SwigDirector_ViewImpl *darg = 0;
61183   float result;
61184
61185   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61186   arg2 = (float)jarg2;
61187   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61188   if (!darg) {
61189     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61190     return 0;
61191   }
61192   {
61193     try {
61194       result = (float)(darg)->GetWidthForHeight(arg2);
61195     } catch (std::out_of_range& e) {
61196       {
61197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61198       };
61199     } catch (std::exception& e) {
61200       {
61201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61202       };
61203     } catch (Dali::DaliException e) {
61204       {
61205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61206       };
61207     } catch (...) {
61208       {
61209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61210       };
61211     }
61212   }
61213
61214   jresult = result;
61215   return jresult;
61216 }
61217
61218
61219 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61220   float jresult ;
61221   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61222   float arg2 ;
61223   SwigDirector_ViewImpl *darg = 0;
61224   float result;
61225
61226   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61227   arg2 = (float)jarg2;
61228   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61229   if (!darg) {
61230     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61231     return 0;
61232   }
61233   {
61234     try {
61235       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61236     } catch (std::out_of_range& e) {
61237       {
61238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61239       };
61240     } catch (std::exception& e) {
61241       {
61242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61243       };
61244     } catch (Dali::DaliException e) {
61245       {
61246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61247       };
61248     } catch (...) {
61249       {
61250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61251       };
61252     }
61253   }
61254
61255   jresult = result;
61256   return jresult;
61257 }
61258
61259
61260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61261   unsigned int jresult ;
61262   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61263   Dali::Dimension::Type arg2 ;
61264   SwigDirector_ViewImpl *darg = 0;
61265   bool result;
61266
61267   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61268   arg2 = (Dali::Dimension::Type)jarg2;
61269   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61270   if (!darg) {
61271     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61272     return 0;
61273   }
61274   {
61275     try {
61276       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61277     } catch (std::out_of_range& e) {
61278       {
61279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61280       };
61281     } catch (std::exception& e) {
61282       {
61283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61284       };
61285     } catch (Dali::DaliException e) {
61286       {
61287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61288       };
61289     } catch (...) {
61290       {
61291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61292       };
61293     }
61294   }
61295
61296   jresult = result;
61297   return jresult;
61298 }
61299
61300
61301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61302   unsigned int jresult ;
61303   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61304   Dali::Dimension::Type arg2 ;
61305   SwigDirector_ViewImpl *darg = 0;
61306   bool result;
61307
61308   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61309   arg2 = (Dali::Dimension::Type)jarg2;
61310   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61311   if (!darg) {
61312     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61313     return 0;
61314   }
61315   {
61316     try {
61317       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61318     } catch (std::out_of_range& e) {
61319       {
61320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61321       };
61322     } catch (std::exception& e) {
61323       {
61324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61325       };
61326     } catch (Dali::DaliException e) {
61327       {
61328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61329       };
61330     } catch (...) {
61331       {
61332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61333       };
61334     }
61335   }
61336
61337   jresult = result;
61338   return jresult;
61339 }
61340
61341
61342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61343   unsigned int jresult ;
61344   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61345   SwigDirector_ViewImpl *darg = 0;
61346   bool result;
61347
61348   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61349   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61350   if (!darg) {
61351     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61352     return 0;
61353   }
61354   {
61355     try {
61356       result = (bool)(darg)->RelayoutDependentOnChildren();
61357     } catch (std::out_of_range& e) {
61358       {
61359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61360       };
61361     } catch (std::exception& e) {
61362       {
61363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61364       };
61365     } catch (Dali::DaliException e) {
61366       {
61367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61368       };
61369     } catch (...) {
61370       {
61371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61372       };
61373     }
61374   }
61375
61376   jresult = result;
61377   return jresult;
61378 }
61379
61380
61381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61382   unsigned int jresult ;
61383   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61384   SwigDirector_ViewImpl *darg = 0;
61385   bool result;
61386
61387   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61388   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61389   if (!darg) {
61390     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61391     return 0;
61392   }
61393   {
61394     try {
61395       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61396     } catch (std::out_of_range& e) {
61397       {
61398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61399       };
61400     } catch (std::exception& e) {
61401       {
61402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61403       };
61404     } catch (Dali::DaliException e) {
61405       {
61406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61407       };
61408     } catch (...) {
61409       {
61410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61411       };
61412     }
61413   }
61414
61415   jresult = result;
61416   return jresult;
61417 }
61418
61419
61420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61421   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61422   Dali::Dimension::Type arg2 ;
61423   SwigDirector_ViewImpl *darg = 0;
61424
61425   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61426   arg2 = (Dali::Dimension::Type)jarg2;
61427   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61428   if (!darg) {
61429     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61430     return;
61431   }
61432   {
61433     try {
61434       (darg)->OnCalculateRelayoutSize(arg2);
61435     } catch (std::out_of_range& e) {
61436       {
61437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61438       };
61439     } catch (std::exception& e) {
61440       {
61441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61442       };
61443     } catch (Dali::DaliException e) {
61444       {
61445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61446       };
61447     } catch (...) {
61448       {
61449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61450       };
61451     }
61452   }
61453
61454 }
61455
61456
61457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61458   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61459   Dali::Dimension::Type arg2 ;
61460   SwigDirector_ViewImpl *darg = 0;
61461
61462   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61463   arg2 = (Dali::Dimension::Type)jarg2;
61464   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61465   if (!darg) {
61466     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61467     return;
61468   }
61469   {
61470     try {
61471       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61472     } catch (std::out_of_range& e) {
61473       {
61474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61475       };
61476     } catch (std::exception& e) {
61477       {
61478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61479       };
61480     } catch (Dali::DaliException e) {
61481       {
61482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61483       };
61484     } catch (...) {
61485       {
61486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61487       };
61488     }
61489   }
61490
61491 }
61492
61493
61494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61495   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61496   float arg2 ;
61497   Dali::Dimension::Type arg3 ;
61498   SwigDirector_ViewImpl *darg = 0;
61499
61500   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61501   arg2 = (float)jarg2;
61502   arg3 = (Dali::Dimension::Type)jarg3;
61503   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61504   if (!darg) {
61505     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61506     return;
61507   }
61508   {
61509     try {
61510       (darg)->OnLayoutNegotiated(arg2,arg3);
61511     } catch (std::out_of_range& e) {
61512       {
61513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61514       };
61515     } catch (std::exception& e) {
61516       {
61517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61518       };
61519     } catch (Dali::DaliException e) {
61520       {
61521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61522       };
61523     } catch (...) {
61524       {
61525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61526       };
61527     }
61528   }
61529
61530 }
61531
61532
61533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61534   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61535   float arg2 ;
61536   Dali::Dimension::Type arg3 ;
61537   SwigDirector_ViewImpl *darg = 0;
61538
61539   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61540   arg2 = (float)jarg2;
61541   arg3 = (Dali::Dimension::Type)jarg3;
61542   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61543   if (!darg) {
61544     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61545     return;
61546   }
61547   {
61548     try {
61549       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61550     } catch (std::out_of_range& e) {
61551       {
61552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61553       };
61554     } catch (std::exception& e) {
61555       {
61556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61557       };
61558     } catch (Dali::DaliException e) {
61559       {
61560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61561       };
61562     } catch (...) {
61563       {
61564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61565       };
61566     }
61567   }
61568
61569 }
61570
61571
61572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
61573   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61574
61575   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61576   {
61577     try {
61578       (arg1)->OnInitialize();
61579     } catch (std::out_of_range& e) {
61580       {
61581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61582       };
61583     } catch (std::exception& e) {
61584       {
61585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61586       };
61587     } catch (Dali::DaliException e) {
61588       {
61589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61590       };
61591     } catch (...) {
61592       {
61593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61594       };
61595     }
61596   }
61597
61598 }
61599
61600
61601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61602   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61603
61604   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61605   {
61606     try {
61607       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61608     } catch (std::out_of_range& e) {
61609       {
61610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61611       };
61612     } catch (std::exception& e) {
61613       {
61614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61615       };
61616     } catch (Dali::DaliException e) {
61617       {
61618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61619       };
61620     } catch (...) {
61621       {
61622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61623       };
61624     }
61625   }
61626
61627 }
61628
61629
61630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61631   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61632   Dali::Toolkit::StyleManager arg2 ;
61633   Dali::StyleChange::Type arg3 ;
61634   Dali::Toolkit::StyleManager *argp2 ;
61635
61636   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61637   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61638   if (!argp2) {
61639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61640     return ;
61641   }
61642   arg2 = *argp2;
61643   arg3 = (Dali::StyleChange::Type)jarg3;
61644   {
61645     try {
61646       (arg1)->OnStyleChange(arg2,arg3);
61647     } catch (std::out_of_range& e) {
61648       {
61649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61650       };
61651     } catch (std::exception& e) {
61652       {
61653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61654       };
61655     } catch (Dali::DaliException e) {
61656       {
61657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61658       };
61659     } catch (...) {
61660       {
61661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61662       };
61663     }
61664   }
61665
61666 }
61667
61668
61669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61670   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61671   Dali::Toolkit::StyleManager arg2 ;
61672   Dali::StyleChange::Type arg3 ;
61673   Dali::Toolkit::StyleManager *argp2 ;
61674
61675   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61676   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61677   if (!argp2) {
61678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61679     return ;
61680   }
61681   arg2 = *argp2;
61682   arg3 = (Dali::StyleChange::Type)jarg3;
61683   {
61684     try {
61685       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61686     } catch (std::out_of_range& e) {
61687       {
61688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61689       };
61690     } catch (std::exception& e) {
61691       {
61692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61693       };
61694     } catch (Dali::DaliException e) {
61695       {
61696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61697       };
61698     } catch (...) {
61699       {
61700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61701       };
61702     }
61703   }
61704
61705 }
61706
61707
61708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
61709   unsigned int jresult ;
61710   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61711   bool result;
61712
61713   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61714   {
61715     try {
61716       result = (bool)(arg1)->OnAccessibilityActivated();
61717     } catch (std::out_of_range& e) {
61718       {
61719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61720       };
61721     } catch (std::exception& e) {
61722       {
61723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61724       };
61725     } catch (Dali::DaliException e) {
61726       {
61727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61728       };
61729     } catch (...) {
61730       {
61731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61732       };
61733     }
61734   }
61735
61736   jresult = result;
61737   return jresult;
61738 }
61739
61740
61741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
61742   unsigned int jresult ;
61743   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61744   bool result;
61745
61746   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61747   {
61748     try {
61749       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
61750     } catch (std::out_of_range& e) {
61751       {
61752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61753       };
61754     } catch (std::exception& e) {
61755       {
61756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61757       };
61758     } catch (Dali::DaliException e) {
61759       {
61760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61761       };
61762     } catch (...) {
61763       {
61764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61765       };
61766     }
61767   }
61768
61769   jresult = result;
61770   return jresult;
61771 }
61772
61773
61774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
61775   unsigned int jresult ;
61776   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61777   Dali::PanGesture arg2 ;
61778   Dali::PanGesture *argp2 ;
61779   bool result;
61780
61781   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61782   argp2 = (Dali::PanGesture *)jarg2;
61783   if (!argp2) {
61784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61785     return 0;
61786   }
61787   arg2 = *argp2;
61788   {
61789     try {
61790       result = (bool)(arg1)->OnAccessibilityPan(arg2);
61791     } catch (std::out_of_range& e) {
61792       {
61793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61794       };
61795     } catch (std::exception& e) {
61796       {
61797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61798       };
61799     } catch (Dali::DaliException e) {
61800       {
61801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61802       };
61803     } catch (...) {
61804       {
61805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61806       };
61807     }
61808   }
61809
61810   jresult = result;
61811   return jresult;
61812 }
61813
61814
61815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61816   unsigned int jresult ;
61817   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61818   Dali::PanGesture arg2 ;
61819   Dali::PanGesture *argp2 ;
61820   bool result;
61821
61822   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61823   argp2 = (Dali::PanGesture *)jarg2;
61824   if (!argp2) {
61825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61826     return 0;
61827   }
61828   arg2 = *argp2;
61829   {
61830     try {
61831       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
61832     } catch (std::out_of_range& e) {
61833       {
61834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61835       };
61836     } catch (std::exception& e) {
61837       {
61838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61839       };
61840     } catch (Dali::DaliException e) {
61841       {
61842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61843       };
61844     } catch (...) {
61845       {
61846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61847       };
61848     }
61849   }
61850
61851   jresult = result;
61852   return jresult;
61853 }
61854
61855
61856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
61857   unsigned int jresult ;
61858   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61859   Dali::TouchEvent *arg2 = 0 ;
61860   bool result;
61861
61862   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61863   arg2 = (Dali::TouchEvent *)jarg2;
61864   if (!arg2) {
61865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61866     return 0;
61867   }
61868   {
61869     try {
61870       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61871     } catch (std::out_of_range& e) {
61872       {
61873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61874       };
61875     } catch (std::exception& e) {
61876       {
61877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61878       };
61879     } catch (Dali::DaliException e) {
61880       {
61881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61882       };
61883     } catch (...) {
61884       {
61885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61886       };
61887     }
61888   }
61889
61890   jresult = result;
61891   return jresult;
61892 }
61893
61894
61895 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61896   unsigned int jresult ;
61897   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61898   Dali::TouchEvent *arg2 = 0 ;
61899   bool result;
61900
61901   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61902   arg2 = (Dali::TouchEvent *)jarg2;
61903   if (!arg2) {
61904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61905     return 0;
61906   }
61907   {
61908     try {
61909       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61910     } catch (std::out_of_range& e) {
61911       {
61912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61913       };
61914     } catch (std::exception& e) {
61915       {
61916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61917       };
61918     } catch (Dali::DaliException e) {
61919       {
61920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61921       };
61922     } catch (...) {
61923       {
61924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61925       };
61926     }
61927   }
61928
61929   jresult = result;
61930   return jresult;
61931 }
61932
61933
61934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
61935   unsigned int jresult ;
61936   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61937   bool arg2 ;
61938   bool result;
61939
61940   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61941   arg2 = jarg2 ? true : false;
61942   {
61943     try {
61944       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
61945     } catch (std::out_of_range& e) {
61946       {
61947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61948       };
61949     } catch (std::exception& e) {
61950       {
61951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61952       };
61953     } catch (Dali::DaliException e) {
61954       {
61955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61956       };
61957     } catch (...) {
61958       {
61959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61960       };
61961     }
61962   }
61963
61964   jresult = result;
61965   return jresult;
61966 }
61967
61968
61969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
61970   unsigned int jresult ;
61971   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61972   bool arg2 ;
61973   bool result;
61974
61975   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61976   arg2 = jarg2 ? true : false;
61977   {
61978     try {
61979       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
61980     } catch (std::out_of_range& e) {
61981       {
61982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61983       };
61984     } catch (std::exception& e) {
61985       {
61986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61987       };
61988     } catch (Dali::DaliException e) {
61989       {
61990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61991       };
61992     } catch (...) {
61993       {
61994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61995       };
61996     }
61997   }
61998
61999   jresult = result;
62000   return jresult;
62001 }
62002
62003
62004 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
62005   unsigned int jresult ;
62006   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62007   bool result;
62008
62009   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62010   {
62011     try {
62012       result = (bool)(arg1)->OnAccessibilityZoom();
62013     } catch (std::out_of_range& e) {
62014       {
62015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62016       };
62017     } catch (std::exception& e) {
62018       {
62019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62020       };
62021     } catch (Dali::DaliException e) {
62022       {
62023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62024       };
62025     } catch (...) {
62026       {
62027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62028       };
62029     }
62030   }
62031
62032   jresult = result;
62033   return jresult;
62034 }
62035
62036
62037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
62038   unsigned int jresult ;
62039   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62040   bool result;
62041
62042   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62043   {
62044     try {
62045       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
62046     } catch (std::out_of_range& e) {
62047       {
62048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62049       };
62050     } catch (std::exception& e) {
62051       {
62052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62053       };
62054     } catch (Dali::DaliException e) {
62055       {
62056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62057       };
62058     } catch (...) {
62059       {
62060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62061       };
62062     }
62063   }
62064
62065   jresult = result;
62066   return jresult;
62067 }
62068
62069
62070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62071   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62072
62073   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62074   {
62075     try {
62076       (arg1)->OnKeyInputFocusGained();
62077     } catch (std::out_of_range& e) {
62078       {
62079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62080       };
62081     } catch (std::exception& e) {
62082       {
62083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62084       };
62085     } catch (Dali::DaliException e) {
62086       {
62087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62088       };
62089     } catch (...) {
62090       {
62091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62092       };
62093     }
62094   }
62095
62096 }
62097
62098
62099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62100   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62101
62102   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62103   {
62104     try {
62105       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62106     } catch (std::out_of_range& e) {
62107       {
62108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62109       };
62110     } catch (std::exception& e) {
62111       {
62112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62113       };
62114     } catch (Dali::DaliException e) {
62115       {
62116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62117       };
62118     } catch (...) {
62119       {
62120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62121       };
62122     }
62123   }
62124
62125 }
62126
62127
62128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62129   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62130
62131   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62132   {
62133     try {
62134       (arg1)->OnKeyInputFocusLost();
62135     } catch (std::out_of_range& e) {
62136       {
62137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62138       };
62139     } catch (std::exception& e) {
62140       {
62141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62142       };
62143     } catch (Dali::DaliException e) {
62144       {
62145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62146       };
62147     } catch (...) {
62148       {
62149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62150       };
62151     }
62152   }
62153
62154 }
62155
62156
62157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62158   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62159
62160   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62161   {
62162     try {
62163       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62164     } catch (std::out_of_range& e) {
62165       {
62166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62167       };
62168     } catch (std::exception& e) {
62169       {
62170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62171       };
62172     } catch (Dali::DaliException e) {
62173       {
62174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62175       };
62176     } catch (...) {
62177       {
62178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62179       };
62180     }
62181   }
62182
62183 }
62184
62185
62186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62187   void * jresult ;
62188   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62189   Dali::Actor arg2 ;
62190   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62191   bool arg4 ;
62192   Dali::Actor *argp2 ;
62193   Dali::Actor result;
62194
62195   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62196   argp2 = (Dali::Actor *)jarg2;
62197   if (!argp2) {
62198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62199     return 0;
62200   }
62201   arg2 = *argp2;
62202   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62203   arg4 = jarg4 ? true : false;
62204   {
62205     try {
62206       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62207     } catch (std::out_of_range& e) {
62208       {
62209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62210       };
62211     } catch (std::exception& e) {
62212       {
62213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62214       };
62215     } catch (Dali::DaliException e) {
62216       {
62217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62218       };
62219     } catch (...) {
62220       {
62221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62222       };
62223     }
62224   }
62225
62226   jresult = new Dali::Actor((const Dali::Actor &)result);
62227   return jresult;
62228 }
62229
62230
62231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62232   void * jresult ;
62233   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62234   Dali::Actor arg2 ;
62235   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62236   bool arg4 ;
62237   Dali::Actor *argp2 ;
62238   Dali::Actor result;
62239
62240   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62241   argp2 = (Dali::Actor *)jarg2;
62242   if (!argp2) {
62243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62244     return 0;
62245   }
62246   arg2 = *argp2;
62247   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62248   arg4 = jarg4 ? true : false;
62249   {
62250     try {
62251       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62252     } catch (std::out_of_range& e) {
62253       {
62254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62255       };
62256     } catch (std::exception& e) {
62257       {
62258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62259       };
62260     } catch (Dali::DaliException e) {
62261       {
62262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62263       };
62264     } catch (...) {
62265       {
62266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62267       };
62268     }
62269   }
62270
62271   jresult = new Dali::Actor((const Dali::Actor &)result);
62272   return jresult;
62273 }
62274
62275
62276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62277   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62278   Dali::Actor arg2 ;
62279   Dali::Actor *argp2 ;
62280
62281   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62282   argp2 = (Dali::Actor *)jarg2;
62283   if (!argp2) {
62284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62285     return ;
62286   }
62287   arg2 = *argp2;
62288   {
62289     try {
62290       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62291     } catch (std::out_of_range& e) {
62292       {
62293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62294       };
62295     } catch (std::exception& e) {
62296       {
62297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62298       };
62299     } catch (Dali::DaliException e) {
62300       {
62301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62302       };
62303     } catch (...) {
62304       {
62305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62306       };
62307     }
62308   }
62309
62310 }
62311
62312
62313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62314   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62315   Dali::Actor arg2 ;
62316   Dali::Actor *argp2 ;
62317
62318   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62319   argp2 = (Dali::Actor *)jarg2;
62320   if (!argp2) {
62321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62322     return ;
62323   }
62324   arg2 = *argp2;
62325   {
62326     try {
62327       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62328     } catch (std::out_of_range& e) {
62329       {
62330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62331       };
62332     } catch (std::exception& e) {
62333       {
62334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62335       };
62336     } catch (Dali::DaliException e) {
62337       {
62338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62339       };
62340     } catch (...) {
62341       {
62342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62343       };
62344     }
62345   }
62346
62347 }
62348
62349
62350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62351   unsigned int jresult ;
62352   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62353   bool result;
62354
62355   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62356   {
62357     try {
62358       result = (bool)(arg1)->OnKeyboardEnter();
62359     } catch (std::out_of_range& e) {
62360       {
62361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62362       };
62363     } catch (std::exception& e) {
62364       {
62365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62366       };
62367     } catch (Dali::DaliException e) {
62368       {
62369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62370       };
62371     } catch (...) {
62372       {
62373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62374       };
62375     }
62376   }
62377
62378   jresult = result;
62379   return jresult;
62380 }
62381
62382
62383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62384   unsigned int jresult ;
62385   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62386   bool result;
62387
62388   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62389   {
62390     try {
62391       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62392     } catch (std::out_of_range& e) {
62393       {
62394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62395       };
62396     } catch (std::exception& e) {
62397       {
62398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62399       };
62400     } catch (Dali::DaliException e) {
62401       {
62402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62403       };
62404     } catch (...) {
62405       {
62406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62407       };
62408     }
62409   }
62410
62411   jresult = result;
62412   return jresult;
62413 }
62414
62415
62416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62417   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62418   Dali::PinchGesture *arg2 = 0 ;
62419
62420   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62421   arg2 = (Dali::PinchGesture *)jarg2;
62422   if (!arg2) {
62423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62424     return ;
62425   }
62426   {
62427     try {
62428       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62429     } catch (std::out_of_range& e) {
62430       {
62431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62432       };
62433     } catch (std::exception& e) {
62434       {
62435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62436       };
62437     } catch (Dali::DaliException e) {
62438       {
62439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62440       };
62441     } catch (...) {
62442       {
62443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62444       };
62445     }
62446   }
62447
62448 }
62449
62450
62451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62452   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62453   Dali::PinchGesture *arg2 = 0 ;
62454
62455   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62456   arg2 = (Dali::PinchGesture *)jarg2;
62457   if (!arg2) {
62458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62459     return ;
62460   }
62461   {
62462     try {
62463       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62464     } catch (std::out_of_range& e) {
62465       {
62466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62467       };
62468     } catch (std::exception& e) {
62469       {
62470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62471       };
62472     } catch (Dali::DaliException e) {
62473       {
62474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62475       };
62476     } catch (...) {
62477       {
62478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62479       };
62480     }
62481   }
62482
62483 }
62484
62485
62486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62487   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62488   Dali::PanGesture *arg2 = 0 ;
62489
62490   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62491   arg2 = (Dali::PanGesture *)jarg2;
62492   if (!arg2) {
62493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62494     return ;
62495   }
62496   {
62497     try {
62498       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62499     } catch (std::out_of_range& e) {
62500       {
62501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62502       };
62503     } catch (std::exception& e) {
62504       {
62505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62506       };
62507     } catch (Dali::DaliException e) {
62508       {
62509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62510       };
62511     } catch (...) {
62512       {
62513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62514       };
62515     }
62516   }
62517
62518 }
62519
62520
62521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62522   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62523   Dali::PanGesture *arg2 = 0 ;
62524
62525   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62526   arg2 = (Dali::PanGesture *)jarg2;
62527   if (!arg2) {
62528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62529     return ;
62530   }
62531   {
62532     try {
62533       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62534     } catch (std::out_of_range& e) {
62535       {
62536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62537       };
62538     } catch (std::exception& e) {
62539       {
62540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62541       };
62542     } catch (Dali::DaliException e) {
62543       {
62544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62545       };
62546     } catch (...) {
62547       {
62548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62549       };
62550     }
62551   }
62552
62553 }
62554
62555
62556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62557   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62558   Dali::TapGesture *arg2 = 0 ;
62559
62560   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62561   arg2 = (Dali::TapGesture *)jarg2;
62562   if (!arg2) {
62563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62564     return ;
62565   }
62566   {
62567     try {
62568       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62569     } catch (std::out_of_range& e) {
62570       {
62571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62572       };
62573     } catch (std::exception& e) {
62574       {
62575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62576       };
62577     } catch (Dali::DaliException e) {
62578       {
62579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62580       };
62581     } catch (...) {
62582       {
62583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62584       };
62585     }
62586   }
62587
62588 }
62589
62590
62591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62592   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62593   Dali::TapGesture *arg2 = 0 ;
62594
62595   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62596   arg2 = (Dali::TapGesture *)jarg2;
62597   if (!arg2) {
62598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62599     return ;
62600   }
62601   {
62602     try {
62603       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
62604     } catch (std::out_of_range& e) {
62605       {
62606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62607       };
62608     } catch (std::exception& e) {
62609       {
62610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62611       };
62612     } catch (Dali::DaliException e) {
62613       {
62614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62615       };
62616     } catch (...) {
62617       {
62618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62619       };
62620     }
62621   }
62622
62623 }
62624
62625
62626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62627   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62628   Dali::LongPressGesture *arg2 = 0 ;
62629
62630   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62631   arg2 = (Dali::LongPressGesture *)jarg2;
62632   if (!arg2) {
62633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62634     return ;
62635   }
62636   {
62637     try {
62638       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62639     } catch (std::out_of_range& e) {
62640       {
62641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62642       };
62643     } catch (std::exception& e) {
62644       {
62645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62646       };
62647     } catch (Dali::DaliException e) {
62648       {
62649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62650       };
62651     } catch (...) {
62652       {
62653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62654       };
62655     }
62656   }
62657
62658 }
62659
62660
62661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62662   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62663   Dali::LongPressGesture *arg2 = 0 ;
62664
62665   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62666   arg2 = (Dali::LongPressGesture *)jarg2;
62667   if (!arg2) {
62668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62669     return ;
62670   }
62671   {
62672     try {
62673       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62674     } catch (std::out_of_range& e) {
62675       {
62676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62677       };
62678     } catch (std::exception& e) {
62679       {
62680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62681       };
62682     } catch (Dali::DaliException e) {
62683       {
62684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62685       };
62686     } catch (...) {
62687       {
62688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62689       };
62690     }
62691   }
62692
62693 }
62694
62695
62696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62697   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62698   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62699   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62700
62701   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62702   arg2 = (Dali::SlotObserver *)jarg2;
62703   arg3 = (Dali::CallbackBase *)jarg3;
62704   {
62705     try {
62706       (arg1)->SignalConnected(arg2,arg3);
62707     } catch (std::out_of_range& e) {
62708       {
62709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62710       };
62711     } catch (std::exception& e) {
62712       {
62713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62714       };
62715     } catch (Dali::DaliException e) {
62716       {
62717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62718       };
62719     } catch (...) {
62720       {
62721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62722       };
62723     }
62724   }
62725
62726 }
62727
62728
62729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62730   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62731   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62732   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62733
62734   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62735   arg2 = (Dali::SlotObserver *)jarg2;
62736   arg3 = (Dali::CallbackBase *)jarg3;
62737   {
62738     try {
62739       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62740     } catch (std::out_of_range& e) {
62741       {
62742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62743       };
62744     } catch (std::exception& e) {
62745       {
62746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62747       };
62748     } catch (Dali::DaliException e) {
62749       {
62750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62751       };
62752     } catch (...) {
62753       {
62754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62755       };
62756     }
62757   }
62758
62759 }
62760
62761
62762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62763   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62764   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62765   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62766
62767   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62768   arg2 = (Dali::SlotObserver *)jarg2;
62769   arg3 = (Dali::CallbackBase *)jarg3;
62770   {
62771     try {
62772       (arg1)->SignalDisconnected(arg2,arg3);
62773     } catch (std::out_of_range& e) {
62774       {
62775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62776       };
62777     } catch (std::exception& e) {
62778       {
62779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62780       };
62781     } catch (Dali::DaliException e) {
62782       {
62783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62784       };
62785     } catch (...) {
62786       {
62787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62788       };
62789     }
62790   }
62791
62792 }
62793
62794
62795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62796   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62797   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62798   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62799
62800   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62801   arg2 = (Dali::SlotObserver *)jarg2;
62802   arg3 = (Dali::CallbackBase *)jarg3;
62803   {
62804     try {
62805       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62806     } catch (std::out_of_range& e) {
62807       {
62808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62809       };
62810     } catch (std::exception& e) {
62811       {
62812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62813       };
62814     } catch (Dali::DaliException e) {
62815       {
62816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62817       };
62818     } catch (...) {
62819       {
62820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62821       };
62822     }
62823   }
62824
62825 }
62826
62827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_director_connect(void *objarg, SwigDirector_ViewImpl::SWIG_Callback0_t callback0, SwigDirector_ViewImpl::SWIG_Callback1_t callback1, SwigDirector_ViewImpl::SWIG_Callback2_t callback2, SwigDirector_ViewImpl::SWIG_Callback3_t callback3, SwigDirector_ViewImpl::SWIG_Callback4_t callback4, SwigDirector_ViewImpl::SWIG_Callback5_t callback5, SwigDirector_ViewImpl::SWIG_Callback6_t callback6, SwigDirector_ViewImpl::SWIG_Callback8_t callback8, SwigDirector_ViewImpl::SWIG_Callback9_t callback9, SwigDirector_ViewImpl::SWIG_Callback10_t callback10, SwigDirector_ViewImpl::SWIG_Callback11_t callback11, SwigDirector_ViewImpl::SWIG_Callback12_t callback12, SwigDirector_ViewImpl::SWIG_Callback13_t callback13, SwigDirector_ViewImpl::SWIG_Callback14_t callback14, SwigDirector_ViewImpl::SWIG_Callback15_t callback15, SwigDirector_ViewImpl::SWIG_Callback16_t callback16, SwigDirector_ViewImpl::SWIG_Callback17_t callback17, SwigDirector_ViewImpl::SWIG_Callback18_t callback18, SwigDirector_ViewImpl::SWIG_Callback19_t callback19, SwigDirector_ViewImpl::SWIG_Callback20_t callback20, SwigDirector_ViewImpl::SWIG_Callback21_t callback21, SwigDirector_ViewImpl::SWIG_Callback24_t callback24, SwigDirector_ViewImpl::SWIG_Callback25_t callback25, SwigDirector_ViewImpl::SWIG_Callback26_t callback26, SwigDirector_ViewImpl::SWIG_Callback27_t callback27, SwigDirector_ViewImpl::SWIG_Callback28_t callback28, SwigDirector_ViewImpl::SWIG_Callback29_t callback29, SwigDirector_ViewImpl::SWIG_Callback30_t callback30, SwigDirector_ViewImpl::SWIG_Callback31_t callback31, SwigDirector_ViewImpl::SWIG_Callback32_t callback32, SwigDirector_ViewImpl::SWIG_Callback33_t callback33, SwigDirector_ViewImpl::SWIG_Callback34_t callback34, SwigDirector_ViewImpl::SWIG_Callback35_t callback35, SwigDirector_ViewImpl::SWIG_Callback36_t callback36, SwigDirector_ViewImpl::SWIG_Callback37_t callback37, SwigDirector_ViewImpl::SWIG_Callback38_t callback38, SwigDirector_ViewImpl::SWIG_Callback39_t callback39, SwigDirector_ViewImpl::SWIG_Callback40_t callback40) {
62828   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62829   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62830   if (director) {
62831     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback8, callback9, callback10, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback24, callback25, callback26, callback27, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40);
62832   }
62833 }
62834
62835
62836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
62837   void * jresult ;
62838   Dali::Toolkit::Control *arg1 = 0 ;
62839   Dali::Toolkit::Internal::Control *result = 0 ;
62840
62841   arg1 = (Dali::Toolkit::Control *)jarg1;
62842   if (!arg1) {
62843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62844     return 0;
62845   }
62846   {
62847     try {
62848       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62849     } catch (std::out_of_range& e) {
62850       {
62851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62852       };
62853     } catch (std::exception& e) {
62854       {
62855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62856       };
62857     } catch (Dali::DaliException e) {
62858       {
62859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62860       };
62861     } catch (...) {
62862       {
62863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62864       };
62865     }
62866   }
62867
62868   jresult = (void *)result;
62869   return jresult;
62870 }
62871
62872
62873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
62874   int jresult ;
62875   int result;
62876
62877   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
62878   jresult = (int)result;
62879   return jresult;
62880 }
62881
62882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
62883   int jresult ;
62884   int result;
62885
62886   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
62887   jresult = (int)result;
62888   return jresult;
62889 }
62890
62891
62892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
62893   int jresult ;
62894   int result;
62895
62896   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
62897   jresult = (int)result;
62898   return jresult;
62899 }
62900
62901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
62902   int jresult ;
62903   int result;
62904
62905   result = (int)Dali::Toolkit::Control::Property::MARGIN;
62906   jresult = (int)result;
62907   return jresult;
62908 }
62909
62910
62911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
62912   int jresult ;
62913   int result;
62914
62915   result = (int)Dali::Toolkit::Control::Property::PADDING;
62916   jresult = (int)result;
62917   return jresult;
62918 }
62919
62920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
62921   int jresult ;
62922   int result;
62923
62924   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
62925   jresult = (int)result;
62926   return jresult;
62927 }
62928
62929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
62930   void * jresult ;
62931   Dali::Toolkit::Control::Property *result = 0 ;
62932
62933   {
62934     try {
62935       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
62936     } catch (std::out_of_range& e) {
62937       {
62938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62939       };
62940     } catch (std::exception& e) {
62941       {
62942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62943       };
62944     } catch (Dali::DaliException e) {
62945       {
62946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62947       };
62948     } catch (...) {
62949       {
62950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62951       };
62952     }
62953   }
62954
62955   jresult = (void *)result;
62956   return jresult;
62957 }
62958
62959
62960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
62961   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
62962
62963   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
62964   {
62965     try {
62966       delete arg1;
62967     } catch (std::out_of_range& e) {
62968       {
62969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62970       };
62971     } catch (std::exception& e) {
62972       {
62973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62974       };
62975     } catch (Dali::DaliException e) {
62976       {
62977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62978       };
62979     } catch (...) {
62980       {
62981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62982       };
62983     }
62984   }
62985
62986 }
62987
62988
62989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
62990   void * jresult ;
62991   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
62992
62993   {
62994     try {
62995       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
62996     } catch (std::out_of_range& e) {
62997       {
62998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62999       };
63000     } catch (std::exception& e) {
63001       {
63002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63003       };
63004     } catch (Dali::DaliException e) {
63005       {
63006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63007       };
63008     } catch (...) {
63009       {
63010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63011       };
63012     }
63013   }
63014
63015   jresult = (void *)result;
63016   return jresult;
63017 }
63018
63019
63020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
63021   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
63022
63023   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
63024   {
63025     try {
63026       delete arg1;
63027     } catch (std::out_of_range& e) {
63028       {
63029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63030       };
63031     } catch (std::exception& e) {
63032       {
63033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63034       };
63035     } catch (Dali::DaliException e) {
63036       {
63037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63038       };
63039     } catch (...) {
63040       {
63041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63042       };
63043     }
63044   }
63045
63046 }
63047
63048
63049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
63050   void * jresult ;
63051   Dali::Toolkit::Control result;
63052
63053   {
63054     try {
63055       result = Dali::Toolkit::Control::New();
63056     } catch (std::out_of_range& e) {
63057       {
63058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63059       };
63060     } catch (std::exception& e) {
63061       {
63062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63063       };
63064     } catch (Dali::DaliException e) {
63065       {
63066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63067       };
63068     } catch (...) {
63069       {
63070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63071       };
63072     }
63073   }
63074
63075   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63076   return jresult;
63077 }
63078
63079
63080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
63081   void * jresult ;
63082   Dali::Toolkit::Control *result = 0 ;
63083
63084   {
63085     try {
63086       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63087     } catch (std::out_of_range& e) {
63088       {
63089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63090       };
63091     } catch (std::exception& e) {
63092       {
63093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63094       };
63095     } catch (Dali::DaliException e) {
63096       {
63097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63098       };
63099     } catch (...) {
63100       {
63101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63102       };
63103     }
63104   }
63105
63106   jresult = (void *)result;
63107   return jresult;
63108 }
63109
63110
63111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63112   void * jresult ;
63113   Dali::Toolkit::Control *arg1 = 0 ;
63114   Dali::Toolkit::Control *result = 0 ;
63115
63116   arg1 = (Dali::Toolkit::Control *)jarg1;
63117   if (!arg1) {
63118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63119     return 0;
63120   }
63121   {
63122     try {
63123       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63124     } catch (std::out_of_range& e) {
63125       {
63126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63127       };
63128     } catch (std::exception& e) {
63129       {
63130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63131       };
63132     } catch (Dali::DaliException e) {
63133       {
63134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63135       };
63136     } catch (...) {
63137       {
63138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63139       };
63140     }
63141   }
63142
63143   jresult = (void *)result;
63144   return jresult;
63145 }
63146
63147
63148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63149   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63150
63151   arg1 = (Dali::Toolkit::Control *)jarg1;
63152   {
63153     try {
63154       delete arg1;
63155     } catch (std::out_of_range& e) {
63156       {
63157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63158       };
63159     } catch (std::exception& e) {
63160       {
63161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63162       };
63163     } catch (Dali::DaliException e) {
63164       {
63165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63166       };
63167     } catch (...) {
63168       {
63169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63170       };
63171     }
63172   }
63173
63174 }
63175
63176
63177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63178   void * jresult ;
63179   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63180   Dali::Toolkit::Control *arg2 = 0 ;
63181   Dali::Toolkit::Control *result = 0 ;
63182
63183   arg1 = (Dali::Toolkit::Control *)jarg1;
63184   arg2 = (Dali::Toolkit::Control *)jarg2;
63185   if (!arg2) {
63186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63187     return 0;
63188   }
63189   {
63190     try {
63191       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63192     } catch (std::out_of_range& e) {
63193       {
63194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63195       };
63196     } catch (std::exception& e) {
63197       {
63198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63199       };
63200     } catch (Dali::DaliException e) {
63201       {
63202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63203       };
63204     } catch (...) {
63205       {
63206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63207       };
63208     }
63209   }
63210
63211   jresult = (void *)result;
63212   return jresult;
63213 }
63214
63215
63216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63217   void * jresult ;
63218   Dali::BaseHandle arg1 ;
63219   Dali::BaseHandle *argp1 ;
63220   Dali::Toolkit::Control result;
63221
63222   argp1 = (Dali::BaseHandle *)jarg1;
63223   if (!argp1) {
63224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63225     return 0;
63226   }
63227   arg1 = *argp1;
63228   {
63229     try {
63230       result = Dali::Toolkit::Control::DownCast(arg1);
63231     } catch (std::out_of_range& e) {
63232       {
63233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63234       };
63235     } catch (std::exception& e) {
63236       {
63237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63238       };
63239     } catch (Dali::DaliException e) {
63240       {
63241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63242       };
63243     } catch (...) {
63244       {
63245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63246       };
63247     }
63248   }
63249
63250   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63251   return jresult;
63252 }
63253
63254
63255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63256   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63257
63258   arg1 = (Dali::Toolkit::Control *)jarg1;
63259   {
63260     try {
63261       (arg1)->SetKeyInputFocus();
63262     } catch (std::out_of_range& e) {
63263       {
63264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63265       };
63266     } catch (std::exception& e) {
63267       {
63268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63269       };
63270     } catch (Dali::DaliException e) {
63271       {
63272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63273       };
63274     } catch (...) {
63275       {
63276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63277       };
63278     }
63279   }
63280
63281 }
63282
63283
63284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63285   unsigned int jresult ;
63286   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63287   bool result;
63288
63289   arg1 = (Dali::Toolkit::Control *)jarg1;
63290   {
63291     try {
63292       result = (bool)(arg1)->HasKeyInputFocus();
63293     } catch (std::out_of_range& e) {
63294       {
63295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63296       };
63297     } catch (std::exception& e) {
63298       {
63299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63300       };
63301     } catch (Dali::DaliException e) {
63302       {
63303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63304       };
63305     } catch (...) {
63306       {
63307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63308       };
63309     }
63310   }
63311
63312   jresult = result;
63313   return jresult;
63314 }
63315
63316
63317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63318   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63319
63320   arg1 = (Dali::Toolkit::Control *)jarg1;
63321   {
63322     try {
63323       (arg1)->ClearKeyInputFocus();
63324     } catch (std::out_of_range& e) {
63325       {
63326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63327       };
63328     } catch (std::exception& e) {
63329       {
63330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63331       };
63332     } catch (Dali::DaliException e) {
63333       {
63334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63335       };
63336     } catch (...) {
63337       {
63338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63339       };
63340     }
63341   }
63342
63343 }
63344
63345
63346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63347   void * jresult ;
63348   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63349   Dali::PinchGestureDetector result;
63350
63351   arg1 = (Dali::Toolkit::Control *)jarg1;
63352   {
63353     try {
63354       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63355     } catch (std::out_of_range& e) {
63356       {
63357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63358       };
63359     } catch (std::exception& e) {
63360       {
63361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63362       };
63363     } catch (Dali::DaliException e) {
63364       {
63365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63366       };
63367     } catch (...) {
63368       {
63369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63370       };
63371     }
63372   }
63373
63374   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63375   return jresult;
63376 }
63377
63378
63379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63380   void * jresult ;
63381   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63382   Dali::PanGestureDetector result;
63383
63384   arg1 = (Dali::Toolkit::Control *)jarg1;
63385   {
63386     try {
63387       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63388     } catch (std::out_of_range& e) {
63389       {
63390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63391       };
63392     } catch (std::exception& e) {
63393       {
63394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63395       };
63396     } catch (Dali::DaliException e) {
63397       {
63398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63399       };
63400     } catch (...) {
63401       {
63402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63403       };
63404     }
63405   }
63406
63407   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63408   return jresult;
63409 }
63410
63411
63412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63413   void * jresult ;
63414   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63415   Dali::TapGestureDetector result;
63416
63417   arg1 = (Dali::Toolkit::Control *)jarg1;
63418   {
63419     try {
63420       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63421     } catch (std::out_of_range& e) {
63422       {
63423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63424       };
63425     } catch (std::exception& e) {
63426       {
63427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63428       };
63429     } catch (Dali::DaliException e) {
63430       {
63431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63432       };
63433     } catch (...) {
63434       {
63435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63436       };
63437     }
63438   }
63439
63440   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63441   return jresult;
63442 }
63443
63444
63445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63446   void * jresult ;
63447   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63448   Dali::LongPressGestureDetector result;
63449
63450   arg1 = (Dali::Toolkit::Control *)jarg1;
63451   {
63452     try {
63453       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63454     } catch (std::out_of_range& e) {
63455       {
63456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63457       };
63458     } catch (std::exception& e) {
63459       {
63460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63461       };
63462     } catch (Dali::DaliException e) {
63463       {
63464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63465       };
63466     } catch (...) {
63467       {
63468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63469       };
63470     }
63471   }
63472
63473   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63474   return jresult;
63475 }
63476
63477
63478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63479   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63480   std::string *arg2 = 0 ;
63481
63482   arg1 = (Dali::Toolkit::Control *)jarg1;
63483   if (!jarg2) {
63484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63485     return ;
63486   }
63487   std::string arg2_str(jarg2);
63488   arg2 = &arg2_str;
63489   {
63490     try {
63491       (arg1)->SetStyleName((std::string const &)*arg2);
63492     } catch (std::out_of_range& e) {
63493       {
63494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63495       };
63496     } catch (std::exception& e) {
63497       {
63498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63499       };
63500     } catch (Dali::DaliException e) {
63501       {
63502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63503       };
63504     } catch (...) {
63505       {
63506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63507       };
63508     }
63509   }
63510
63511
63512   //argout typemap for const std::string&
63513
63514 }
63515
63516
63517 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63518   char * jresult ;
63519   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63520   std::string *result = 0 ;
63521
63522   arg1 = (Dali::Toolkit::Control *)jarg1;
63523   {
63524     try {
63525       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63526     } catch (std::out_of_range& e) {
63527       {
63528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63529       };
63530     } catch (std::exception& e) {
63531       {
63532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63533       };
63534     } catch (Dali::DaliException e) {
63535       {
63536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63537       };
63538     } catch (...) {
63539       {
63540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63541       };
63542     }
63543   }
63544
63545   jresult = SWIG_csharp_string_callback(result->c_str());
63546   return jresult;
63547 }
63548
63549
63550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63551   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63552   Dali::Vector4 *arg2 = 0 ;
63553
63554   arg1 = (Dali::Toolkit::Control *)jarg1;
63555   arg2 = (Dali::Vector4 *)jarg2;
63556   if (!arg2) {
63557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63558     return ;
63559   }
63560   {
63561     try {
63562       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63563     } catch (std::out_of_range& e) {
63564       {
63565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63566       };
63567     } catch (std::exception& e) {
63568       {
63569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63570       };
63571     } catch (Dali::DaliException e) {
63572       {
63573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63574       };
63575     } catch (...) {
63576       {
63577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63578       };
63579     }
63580   }
63581
63582 }
63583
63584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
63585   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63586
63587   arg1 = (Dali::Toolkit::Control *)jarg1;
63588   {
63589     try {
63590       (arg1)->ClearBackground();
63591     } catch (std::out_of_range& e) {
63592       {
63593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63594       };
63595     } catch (std::exception& e) {
63596       {
63597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63598       };
63599     } catch (Dali::DaliException e) {
63600       {
63601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63602       };
63603     } catch (...) {
63604       {
63605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63606       };
63607     }
63608   }
63609
63610 }
63611
63612
63613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
63614   void * jresult ;
63615   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63616   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63617
63618   arg1 = (Dali::Toolkit::Control *)jarg1;
63619   {
63620     try {
63621       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63622     } catch (std::out_of_range& e) {
63623       {
63624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63625       };
63626     } catch (std::exception& e) {
63627       {
63628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63629       };
63630     } catch (Dali::DaliException e) {
63631       {
63632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63633       };
63634     } catch (...) {
63635       {
63636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63637       };
63638     }
63639   }
63640
63641   jresult = (void *)result;
63642   return jresult;
63643 }
63644
63645
63646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
63647   void * jresult ;
63648   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63649   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63650
63651   arg1 = (Dali::Toolkit::Control *)jarg1;
63652   {
63653     try {
63654       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63655     } catch (std::out_of_range& e) {
63656       {
63657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63658       };
63659     } catch (std::exception& e) {
63660       {
63661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63662       };
63663     } catch (Dali::DaliException e) {
63664       {
63665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63666       };
63667     } catch (...) {
63668       {
63669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63670       };
63671     }
63672   }
63673
63674   jresult = (void *)result;
63675   return jresult;
63676 }
63677
63678
63679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
63680   void * jresult ;
63681   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63682   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63683
63684   arg1 = (Dali::Toolkit::Control *)jarg1;
63685   {
63686     try {
63687       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63688     } catch (std::out_of_range& e) {
63689       {
63690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63691       };
63692     } catch (std::exception& e) {
63693       {
63694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63695       };
63696     } catch (Dali::DaliException e) {
63697       {
63698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63699       };
63700     } catch (...) {
63701       {
63702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63703       };
63704     }
63705   }
63706
63707   jresult = (void *)result;
63708   return jresult;
63709 }
63710
63711
63712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
63713   void * jresult ;
63714   Dali::Toolkit::Internal::Control *arg1 = 0 ;
63715   Dali::Toolkit::Control *result = 0 ;
63716
63717   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63718   if (!arg1) {
63719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63720     return 0;
63721   }
63722   {
63723     try {
63724       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63725     } catch (std::out_of_range& e) {
63726       {
63727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63728       };
63729     } catch (std::exception& e) {
63730       {
63731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63732       };
63733     } catch (Dali::DaliException e) {
63734       {
63735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63736       };
63737     } catch (...) {
63738       {
63739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63740       };
63741     }
63742   }
63743
63744   jresult = (void *)result;
63745   return jresult;
63746 }
63747
63748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
63749 {
63750   int jresult;
63751   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63752   arg1 = (Dali::Toolkit::Control *)jarg1;
63753
63754   if (!arg1) {
63755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63756     return 0;
63757   }
63758
63759   Dali::Property::Index arg2 = 0 ;
63760   arg2 = (Dali::Property::Index)jarg2;
63761
63762   Toolkit::Visual::ResourceStatus result;
63763   {
63764     try {
63765       result = arg1->GetVisualResourceStatus(arg2);
63766     } catch (std::out_of_range& e) {
63767       {
63768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63769       };
63770     } catch (std::exception& e) {
63771       {
63772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63773       };
63774     } catch (...) {
63775       {
63776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63777       };
63778     }
63779   }
63780   jresult = (int)(result);
63781   return jresult;
63782 }
63783
63784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
63785 {
63786   void * jresult;
63787   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63788   arg1 = (Dali::Toolkit::Control *)jarg1;
63789
63790   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
63791
63792   Dali::Toolkit::TransitionData *arg2 = 0 ;
63793   Dali::Animation result;
63794
63795   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
63796   if (!arg2) {
63797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
63798     return 0;
63799   }
63800   {
63801     try {
63802       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
63803     } catch (std::out_of_range& e) {
63804       {
63805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63806       };
63807     } catch (std::exception& e) {
63808       {
63809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63810       };
63811     } catch (Dali::DaliException e) {
63812       {
63813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63814       };
63815     } catch (...) {
63816       {
63817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63818       };
63819     }
63820   }
63821
63822   jresult = new Dali::Animation((const Dali::Animation &)result);
63823   return jresult;
63824 }
63825
63826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
63827 {
63828   Dali::Toolkit::Control arg1;
63829   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
63830
63831   if (!argp1) {
63832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63833   }
63834   arg1 = *argp1;
63835
63836   Dali::Property::Index arg2 = 0 ;
63837   arg2 = (Dali::Property::Index)jarg2;
63838
63839   Dali::Property::Index arg3 = 0 ;
63840   arg3 = (Dali::Property::Index)jarg3;
63841
63842   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
63843
63844   {
63845     try {
63846       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
63847     } catch (std::out_of_range& e) {
63848       {
63849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63850       };
63851     } catch (std::exception& e) {
63852       {
63853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63854       };
63855     } catch (...) {
63856       {
63857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63858       };
63859     }
63860   }
63861
63862
63863 }
63864
63865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
63866   void * jresult ;
63867   Dali::Toolkit::Control *arg1 = 0 ;
63868   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
63869
63870   arg1 = (Dali::Toolkit::Control *)jarg1;
63871   if (!arg1) {
63872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63873     return 0;
63874   }
63875   {
63876     try {
63877       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
63878     } catch (std::out_of_range& e) {
63879       {
63880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63881       };
63882     } catch (std::exception& e) {
63883       {
63884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63885       };
63886     } catch (Dali::DaliException e) {
63887       {
63888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63889       };
63890     } catch (...) {
63891       {
63892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63893       };
63894     }
63895   }
63896
63897   jresult = (void *)result;
63898   return jresult;
63899 }
63900
63901
63902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
63903   unsigned int jresult ;
63904   Dali::Toolkit::Control *arg1 = 0 ;
63905   bool result;
63906
63907   arg1 = (Dali::Toolkit::Control *)jarg1;
63908   if (!arg1) {
63909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63910     return 0;
63911   }
63912   {
63913     try {
63914       result = (bool)arg1->IsResourceReady();
63915     } catch (std::out_of_range& e) {
63916       {
63917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63918       };
63919     } catch (std::exception& e) {
63920       {
63921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63922       };
63923     } catch (Dali::DaliException e) {
63924       {
63925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63926       };
63927     } catch (...) {
63928       {
63929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63930       };
63931     }
63932   }
63933
63934   jresult = result;
63935   return jresult;
63936 }
63937
63938
63939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
63940   void * jresult ;
63941   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
63942
63943   {
63944     try {
63945       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
63946     } catch (std::out_of_range& e) {
63947       {
63948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63949       };
63950     } catch (std::exception& e) {
63951       {
63952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63953       };
63954     } catch (Dali::DaliException e) {
63955       {
63956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63957       };
63958     } catch (...) {
63959       {
63960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63961       };
63962     }
63963   }
63964
63965   jresult = (void *)result;
63966   return jresult;
63967 }
63968
63969
63970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
63971   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63972
63973   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63974   {
63975     try {
63976       delete arg1;
63977     } catch (std::out_of_range& e) {
63978       {
63979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63980       };
63981     } catch (std::exception& e) {
63982       {
63983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63984       };
63985     } catch (Dali::DaliException e) {
63986       {
63987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63988       };
63989     } catch (...) {
63990       {
63991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63992       };
63993     }
63994   }
63995
63996 }
63997
63998
63999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
64000   void * jresult ;
64001   Dali::Toolkit::KeyInputFocusManager result;
64002
64003   {
64004     try {
64005       result = Dali::Toolkit::KeyInputFocusManager::Get();
64006     } catch (std::out_of_range& e) {
64007       {
64008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64009       };
64010     } catch (std::exception& e) {
64011       {
64012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64013       };
64014     } catch (Dali::DaliException e) {
64015       {
64016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64017       };
64018     } catch (...) {
64019       {
64020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64021       };
64022     }
64023   }
64024
64025   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
64026   return jresult;
64027 }
64028
64029
64030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
64031   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64032   Dali::Toolkit::Control arg2 ;
64033   Dali::Toolkit::Control *argp2 ;
64034
64035   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64036   argp2 = (Dali::Toolkit::Control *)jarg2;
64037   if (!argp2) {
64038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64039     return ;
64040   }
64041   arg2 = *argp2;
64042   {
64043     try {
64044       (arg1)->SetFocus(arg2);
64045     } catch (std::out_of_range& e) {
64046       {
64047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64048       };
64049     } catch (std::exception& e) {
64050       {
64051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64052       };
64053     } catch (Dali::DaliException e) {
64054       {
64055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64056       };
64057     } catch (...) {
64058       {
64059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64060       };
64061     }
64062   }
64063
64064 }
64065
64066
64067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
64068   void * jresult ;
64069   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64070   Dali::Toolkit::Control result;
64071
64072   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64073   {
64074     try {
64075       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
64076     } catch (std::out_of_range& e) {
64077       {
64078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64079       };
64080     } catch (std::exception& e) {
64081       {
64082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64083       };
64084     } catch (Dali::DaliException e) {
64085       {
64086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64087       };
64088     } catch (...) {
64089       {
64090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64091       };
64092     }
64093   }
64094
64095   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64096   return jresult;
64097 }
64098
64099
64100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64101   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64102   Dali::Toolkit::Control arg2 ;
64103   Dali::Toolkit::Control *argp2 ;
64104
64105   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64106   argp2 = (Dali::Toolkit::Control *)jarg2;
64107   if (!argp2) {
64108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64109     return ;
64110   }
64111   arg2 = *argp2;
64112   {
64113     try {
64114       (arg1)->RemoveFocus(arg2);
64115     } catch (std::out_of_range& e) {
64116       {
64117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64118       };
64119     } catch (std::exception& e) {
64120       {
64121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64122       };
64123     } catch (Dali::DaliException e) {
64124       {
64125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64126       };
64127     } catch (...) {
64128       {
64129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64130       };
64131     }
64132   }
64133
64134 }
64135
64136
64137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64138   void * jresult ;
64139   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64140   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64141
64142   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64143   {
64144     try {
64145       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64146     } catch (std::out_of_range& e) {
64147       {
64148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64149       };
64150     } catch (std::exception& e) {
64151       {
64152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64153       };
64154     } catch (Dali::DaliException e) {
64155       {
64156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64157       };
64158     } catch (...) {
64159       {
64160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64161       };
64162     }
64163   }
64164
64165   jresult = (void *)result;
64166   return jresult;
64167 }
64168
64169
64170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
64171   void * jresult ;
64172   Dali::Toolkit::Alignment::Padding *result = 0 ;
64173
64174   {
64175     try {
64176       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64177     } catch (std::out_of_range& e) {
64178       {
64179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64180       };
64181     } catch (std::exception& e) {
64182       {
64183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64184       };
64185     } catch (Dali::DaliException e) {
64186       {
64187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64188       };
64189     } catch (...) {
64190       {
64191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64192       };
64193     }
64194   }
64195
64196   jresult = (void *)result;
64197   return jresult;
64198 }
64199
64200
64201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64202   void * jresult ;
64203   float arg1 ;
64204   float arg2 ;
64205   float arg3 ;
64206   float arg4 ;
64207   Dali::Toolkit::Alignment::Padding *result = 0 ;
64208
64209   arg1 = (float)jarg1;
64210   arg2 = (float)jarg2;
64211   arg3 = (float)jarg3;
64212   arg4 = (float)jarg4;
64213   {
64214     try {
64215       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64216     } catch (std::out_of_range& e) {
64217       {
64218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64219       };
64220     } catch (std::exception& e) {
64221       {
64222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64223       };
64224     } catch (Dali::DaliException e) {
64225       {
64226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64227       };
64228     } catch (...) {
64229       {
64230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64231       };
64232     }
64233   }
64234
64235   jresult = (void *)result;
64236   return jresult;
64237 }
64238
64239
64240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_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)->left = arg2;
64247 }
64248
64249
64250 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_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)->left);
64257   jresult = result;
64258   return jresult;
64259 }
64260
64261
64262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_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)->right = arg2;
64269 }
64270
64271
64272 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_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)->right);
64279   jresult = result;
64280   return jresult;
64281 }
64282
64283
64284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_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)->top = arg2;
64291 }
64292
64293
64294 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_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)->top);
64301   jresult = result;
64302   return jresult;
64303 }
64304
64305
64306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64307   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64308   float arg2 ;
64309
64310   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64311   arg2 = (float)jarg2;
64312   if (arg1) (arg1)->bottom = arg2;
64313 }
64314
64315
64316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64317   float jresult ;
64318   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64319   float result;
64320
64321   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64322   result = (float) ((arg1)->bottom);
64323   jresult = result;
64324   return jresult;
64325 }
64326
64327
64328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64329   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64330
64331   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64332   {
64333     try {
64334       delete arg1;
64335     } catch (std::out_of_range& e) {
64336       {
64337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64338       };
64339     } catch (std::exception& e) {
64340       {
64341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64342       };
64343     } catch (Dali::DaliException e) {
64344       {
64345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64346       };
64347     } catch (...) {
64348       {
64349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64350       };
64351     }
64352   }
64353
64354 }
64355
64356
64357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64358   void * jresult ;
64359   Dali::Toolkit::Alignment *result = 0 ;
64360
64361   {
64362     try {
64363       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64364     } catch (std::out_of_range& e) {
64365       {
64366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64367       };
64368     } catch (std::exception& e) {
64369       {
64370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64371       };
64372     } catch (Dali::DaliException e) {
64373       {
64374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64375       };
64376     } catch (...) {
64377       {
64378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64379       };
64380     }
64381   }
64382
64383   jresult = (void *)result;
64384   return jresult;
64385 }
64386
64387
64388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64389   void * jresult ;
64390   Dali::Toolkit::Alignment::Type arg1 ;
64391   Dali::Toolkit::Alignment::Type arg2 ;
64392   Dali::Toolkit::Alignment result;
64393
64394   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64395   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64396   {
64397     try {
64398       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64399     } catch (std::out_of_range& e) {
64400       {
64401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64402       };
64403     } catch (std::exception& e) {
64404       {
64405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64406       };
64407     } catch (Dali::DaliException e) {
64408       {
64409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64410       };
64411     } catch (...) {
64412       {
64413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64414       };
64415     }
64416   }
64417
64418   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64419   return jresult;
64420 }
64421
64422
64423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64424   void * jresult ;
64425   Dali::Toolkit::Alignment::Type arg1 ;
64426   Dali::Toolkit::Alignment result;
64427
64428   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64429   {
64430     try {
64431       result = Dali::Toolkit::Alignment::New(arg1);
64432     } catch (std::out_of_range& e) {
64433       {
64434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64435       };
64436     } catch (std::exception& e) {
64437       {
64438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64439       };
64440     } catch (Dali::DaliException e) {
64441       {
64442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64443       };
64444     } catch (...) {
64445       {
64446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64447       };
64448     }
64449   }
64450
64451   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64452   return jresult;
64453 }
64454
64455
64456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64457   void * jresult ;
64458   Dali::Toolkit::Alignment result;
64459
64460   {
64461     try {
64462       result = Dali::Toolkit::Alignment::New();
64463     } catch (std::out_of_range& e) {
64464       {
64465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64466       };
64467     } catch (std::exception& e) {
64468       {
64469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64470       };
64471     } catch (Dali::DaliException e) {
64472       {
64473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64474       };
64475     } catch (...) {
64476       {
64477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64478       };
64479     }
64480   }
64481
64482   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64483   return jresult;
64484 }
64485
64486
64487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64488   void * jresult ;
64489   Dali::Toolkit::Alignment *arg1 = 0 ;
64490   Dali::Toolkit::Alignment *result = 0 ;
64491
64492   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64493   if (!arg1) {
64494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64495     return 0;
64496   }
64497   {
64498     try {
64499       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64500     } catch (std::out_of_range& e) {
64501       {
64502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64503       };
64504     } catch (std::exception& e) {
64505       {
64506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64507       };
64508     } catch (Dali::DaliException e) {
64509       {
64510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64511       };
64512     } catch (...) {
64513       {
64514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64515       };
64516     }
64517   }
64518
64519   jresult = (void *)result;
64520   return jresult;
64521 }
64522
64523
64524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64525   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64526
64527   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64528   {
64529     try {
64530       delete arg1;
64531     } catch (std::out_of_range& e) {
64532       {
64533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64534       };
64535     } catch (std::exception& e) {
64536       {
64537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64538       };
64539     } catch (Dali::DaliException e) {
64540       {
64541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64542       };
64543     } catch (...) {
64544       {
64545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64546       };
64547     }
64548   }
64549
64550 }
64551
64552
64553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64554   void * jresult ;
64555   Dali::BaseHandle arg1 ;
64556   Dali::BaseHandle *argp1 ;
64557   Dali::Toolkit::Alignment result;
64558
64559   argp1 = (Dali::BaseHandle *)jarg1;
64560   if (!argp1) {
64561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64562     return 0;
64563   }
64564   arg1 = *argp1;
64565   {
64566     try {
64567       result = Dali::Toolkit::Alignment::DownCast(arg1);
64568     } catch (std::out_of_range& e) {
64569       {
64570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64571       };
64572     } catch (std::exception& e) {
64573       {
64574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64575       };
64576     } catch (Dali::DaliException e) {
64577       {
64578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64579       };
64580     } catch (...) {
64581       {
64582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64583       };
64584     }
64585   }
64586
64587   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64588   return jresult;
64589 }
64590
64591
64592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64593   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64594   Dali::Toolkit::Alignment::Type arg2 ;
64595
64596   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64597   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64598   {
64599     try {
64600       (arg1)->SetAlignmentType(arg2);
64601     } catch (std::out_of_range& e) {
64602       {
64603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64604       };
64605     } catch (std::exception& e) {
64606       {
64607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64608       };
64609     } catch (Dali::DaliException e) {
64610       {
64611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64612       };
64613     } catch (...) {
64614       {
64615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64616       };
64617     }
64618   }
64619
64620 }
64621
64622
64623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64624   int jresult ;
64625   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64626   Dali::Toolkit::Alignment::Type result;
64627
64628   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64629   {
64630     try {
64631       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64632     } catch (std::out_of_range& e) {
64633       {
64634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64635       };
64636     } catch (std::exception& e) {
64637       {
64638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64639       };
64640     } catch (Dali::DaliException e) {
64641       {
64642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64643       };
64644     } catch (...) {
64645       {
64646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64647       };
64648     }
64649   }
64650
64651   jresult = (int)result;
64652   return jresult;
64653 }
64654
64655
64656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64657   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64658   Dali::Toolkit::Alignment::Scaling arg2 ;
64659
64660   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64661   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64662   {
64663     try {
64664       (arg1)->SetScaling(arg2);
64665     } catch (std::out_of_range& e) {
64666       {
64667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64668       };
64669     } catch (std::exception& e) {
64670       {
64671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64672       };
64673     } catch (Dali::DaliException e) {
64674       {
64675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64676       };
64677     } catch (...) {
64678       {
64679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64680       };
64681     }
64682   }
64683
64684 }
64685
64686
64687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64688   int jresult ;
64689   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64690   Dali::Toolkit::Alignment::Scaling result;
64691
64692   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64693   {
64694     try {
64695       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64696     } catch (std::out_of_range& e) {
64697       {
64698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64699       };
64700     } catch (std::exception& e) {
64701       {
64702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64703       };
64704     } catch (Dali::DaliException e) {
64705       {
64706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64707       };
64708     } catch (...) {
64709       {
64710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64711       };
64712     }
64713   }
64714
64715   jresult = (int)result;
64716   return jresult;
64717 }
64718
64719
64720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64721   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64722   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64723
64724   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64725   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64726   if (!arg2) {
64727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64728     return ;
64729   }
64730   {
64731     try {
64732       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64733     } catch (std::out_of_range& e) {
64734       {
64735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64736       };
64737     } catch (std::exception& e) {
64738       {
64739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64740       };
64741     } catch (Dali::DaliException e) {
64742       {
64743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64744       };
64745     } catch (...) {
64746       {
64747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64748       };
64749     }
64750   }
64751
64752 }
64753
64754
64755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
64756   void * jresult ;
64757   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64758   Dali::Toolkit::Alignment::Padding *result = 0 ;
64759
64760   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64761   {
64762     try {
64763       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64764     } catch (std::out_of_range& e) {
64765       {
64766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64767       };
64768     } catch (std::exception& e) {
64769       {
64770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64771       };
64772     } catch (Dali::DaliException e) {
64773       {
64774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64775       };
64776     } catch (...) {
64777       {
64778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64779       };
64780     }
64781   }
64782
64783   jresult = (void *)result;
64784   return jresult;
64785 }
64786
64787
64788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
64789   void * jresult ;
64790   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64791   Dali::Toolkit::Alignment *arg2 = 0 ;
64792   Dali::Toolkit::Alignment *result = 0 ;
64793
64794   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64795   arg2 = (Dali::Toolkit::Alignment *)jarg2;
64796   if (!arg2) {
64797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64798     return 0;
64799   }
64800   {
64801     try {
64802       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
64803     } catch (std::out_of_range& e) {
64804       {
64805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64806       };
64807     } catch (std::exception& e) {
64808       {
64809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64810       };
64811     } catch (Dali::DaliException e) {
64812       {
64813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64814       };
64815     } catch (...) {
64816       {
64817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64818       };
64819     }
64820   }
64821
64822   jresult = (void *)result;
64823   return jresult;
64824 }
64825
64826
64827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
64828   int jresult ;
64829   int result;
64830
64831   result = (int)Dali::Toolkit::Button::Property::DISABLED;
64832   jresult = (int)result;
64833   return jresult;
64834 }
64835
64836
64837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
64838   int jresult ;
64839   int result;
64840
64841   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
64842   jresult = (int)result;
64843   return jresult;
64844 }
64845
64846
64847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
64848   int jresult ;
64849   int result;
64850
64851   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
64852   jresult = (int)result;
64853   return jresult;
64854 }
64855
64856
64857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
64858   int jresult ;
64859   int result;
64860
64861   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
64862   jresult = (int)result;
64863   return jresult;
64864 }
64865
64866
64867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
64868   int jresult ;
64869   int result;
64870
64871   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
64872   jresult = (int)result;
64873   return jresult;
64874 }
64875
64876
64877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
64878   int jresult ;
64879   int result;
64880
64881   result = (int)Dali::Toolkit::Button::Property::SELECTED;
64882   jresult = (int)result;
64883   return jresult;
64884 }
64885
64886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
64887   int jresult ;
64888   int result;
64889
64890   result = (int)Dali::Toolkit::Button::Property::LABEL;
64891   jresult = (int)result;
64892   return jresult;
64893 }
64894
64895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
64896   void * jresult ;
64897   Dali::Toolkit::Button::Property *result = 0 ;
64898
64899   {
64900     try {
64901       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
64902     } catch (std::out_of_range& e) {
64903       {
64904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64905       };
64906     } catch (std::exception& e) {
64907       {
64908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64909       };
64910     } catch (Dali::DaliException e) {
64911       {
64912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64913       };
64914     } catch (...) {
64915       {
64916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64917       };
64918     }
64919   }
64920
64921   jresult = (void *)result;
64922   return jresult;
64923 }
64924
64925
64926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
64927   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
64928
64929   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
64930   {
64931     try {
64932       delete arg1;
64933     } catch (std::out_of_range& e) {
64934       {
64935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64936       };
64937     } catch (std::exception& e) {
64938       {
64939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64940       };
64941     } catch (Dali::DaliException e) {
64942       {
64943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64944       };
64945     } catch (...) {
64946       {
64947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64948       };
64949     }
64950   }
64951
64952 }
64953
64954
64955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
64956   void * jresult ;
64957   Dali::Toolkit::Button *result = 0 ;
64958
64959   {
64960     try {
64961       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
64962     } catch (std::out_of_range& e) {
64963       {
64964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64965       };
64966     } catch (std::exception& e) {
64967       {
64968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64969       };
64970     } catch (Dali::DaliException e) {
64971       {
64972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64973       };
64974     } catch (...) {
64975       {
64976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64977       };
64978     }
64979   }
64980
64981   jresult = (void *)result;
64982   return jresult;
64983 }
64984
64985
64986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
64987   void * jresult ;
64988   Dali::Toolkit::Button *arg1 = 0 ;
64989   Dali::Toolkit::Button *result = 0 ;
64990
64991   arg1 = (Dali::Toolkit::Button *)jarg1;
64992   if (!arg1) {
64993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64994     return 0;
64995   }
64996   {
64997     try {
64998       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
64999     } catch (std::out_of_range& e) {
65000       {
65001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65002       };
65003     } catch (std::exception& e) {
65004       {
65005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65006       };
65007     } catch (Dali::DaliException e) {
65008       {
65009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65010       };
65011     } catch (...) {
65012       {
65013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65014       };
65015     }
65016   }
65017
65018   jresult = (void *)result;
65019   return jresult;
65020 }
65021
65022
65023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
65024   void * jresult ;
65025   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65026   Dali::Toolkit::Button *arg2 = 0 ;
65027   Dali::Toolkit::Button *result = 0 ;
65028
65029   arg1 = (Dali::Toolkit::Button *)jarg1;
65030   arg2 = (Dali::Toolkit::Button *)jarg2;
65031   if (!arg2) {
65032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65033     return 0;
65034   }
65035   {
65036     try {
65037       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
65038     } catch (std::out_of_range& e) {
65039       {
65040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65041       };
65042     } catch (std::exception& e) {
65043       {
65044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65045       };
65046     } catch (Dali::DaliException e) {
65047       {
65048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65049       };
65050     } catch (...) {
65051       {
65052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65053       };
65054     }
65055   }
65056
65057   jresult = (void *)result;
65058   return jresult;
65059 }
65060
65061
65062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
65063   void * jresult ;
65064   Dali::BaseHandle arg1 ;
65065   Dali::BaseHandle *argp1 ;
65066   Dali::Toolkit::Button result;
65067
65068   argp1 = (Dali::BaseHandle *)jarg1;
65069   if (!argp1) {
65070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65071     return 0;
65072   }
65073   arg1 = *argp1;
65074   {
65075     try {
65076       result = Dali::Toolkit::Button::DownCast(arg1);
65077     } catch (std::out_of_range& e) {
65078       {
65079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65080       };
65081     } catch (std::exception& e) {
65082       {
65083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65084       };
65085     } catch (Dali::DaliException e) {
65086       {
65087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65088       };
65089     } catch (...) {
65090       {
65091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65092       };
65093     }
65094   }
65095
65096   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65097   return jresult;
65098 }
65099
65100
65101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65102   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65103
65104   arg1 = (Dali::Toolkit::Button *)jarg1;
65105   {
65106     try {
65107       delete arg1;
65108     } catch (std::out_of_range& e) {
65109       {
65110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65111       };
65112     } catch (std::exception& e) {
65113       {
65114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65115       };
65116     } catch (Dali::DaliException e) {
65117       {
65118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65119       };
65120     } catch (...) {
65121       {
65122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65123       };
65124     }
65125   }
65126
65127 }
65128
65129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65130   void * jresult ;
65131   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65132   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65133
65134   arg1 = (Dali::Toolkit::Button *)jarg1;
65135   {
65136     try {
65137       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65138     } catch (std::out_of_range& e) {
65139       {
65140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65141       };
65142     } catch (std::exception& e) {
65143       {
65144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65145       };
65146     } catch (Dali::DaliException e) {
65147       {
65148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65149       };
65150     } catch (...) {
65151       {
65152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65153       };
65154     }
65155   }
65156
65157   jresult = (void *)result;
65158   return jresult;
65159 }
65160
65161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65162   void * jresult ;
65163   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65164   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65165
65166   arg1 = (Dali::Toolkit::Button *)jarg1;
65167   {
65168     try {
65169       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65170     } catch (std::out_of_range& e) {
65171       {
65172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65173       };
65174     } catch (std::exception& e) {
65175       {
65176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65177       };
65178     } catch (Dali::DaliException e) {
65179       {
65180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65181       };
65182     } catch (...) {
65183       {
65184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65185       };
65186     }
65187   }
65188
65189   jresult = (void *)result;
65190   return jresult;
65191 }
65192
65193
65194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65195   void * jresult ;
65196   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65197   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65198
65199   arg1 = (Dali::Toolkit::Button *)jarg1;
65200   {
65201     try {
65202       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65203     } catch (std::out_of_range& e) {
65204       {
65205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65206       };
65207     } catch (std::exception& e) {
65208       {
65209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65210       };
65211     } catch (Dali::DaliException e) {
65212       {
65213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65214       };
65215     } catch (...) {
65216       {
65217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65218       };
65219     }
65220   }
65221
65222   jresult = (void *)result;
65223   return jresult;
65224 }
65225
65226
65227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65228   void * jresult ;
65229   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65230   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65231
65232   arg1 = (Dali::Toolkit::Button *)jarg1;
65233   {
65234     try {
65235       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65236     } catch (std::out_of_range& e) {
65237       {
65238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65239       };
65240     } catch (std::exception& e) {
65241       {
65242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65243       };
65244     } catch (Dali::DaliException e) {
65245       {
65246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65247       };
65248     } catch (...) {
65249       {
65250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65251       };
65252     }
65253   }
65254
65255   jresult = (void *)result;
65256   return jresult;
65257 }
65258
65259
65260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65261   void * jresult ;
65262   Dali::Toolkit::CheckBoxButton *result = 0 ;
65263
65264   {
65265     try {
65266       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65267     } catch (std::out_of_range& e) {
65268       {
65269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65270       };
65271     } catch (std::exception& e) {
65272       {
65273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65274       };
65275     } catch (Dali::DaliException e) {
65276       {
65277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65278       };
65279     } catch (...) {
65280       {
65281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65282       };
65283     }
65284   }
65285
65286   jresult = (void *)result;
65287   return jresult;
65288 }
65289
65290
65291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65292   void * jresult ;
65293   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65294   Dali::Toolkit::CheckBoxButton *result = 0 ;
65295
65296   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65297   if (!arg1) {
65298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65299     return 0;
65300   }
65301   {
65302     try {
65303       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65304     } catch (std::out_of_range& e) {
65305       {
65306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65307       };
65308     } catch (std::exception& e) {
65309       {
65310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65311       };
65312     } catch (Dali::DaliException e) {
65313       {
65314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65315       };
65316     } catch (...) {
65317       {
65318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65319       };
65320     }
65321   }
65322
65323   jresult = (void *)result;
65324   return jresult;
65325 }
65326
65327
65328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65329   void * jresult ;
65330   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65331   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65332   Dali::Toolkit::CheckBoxButton *result = 0 ;
65333
65334   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65335   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65336   if (!arg2) {
65337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65338     return 0;
65339   }
65340   {
65341     try {
65342       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65343     } catch (std::out_of_range& e) {
65344       {
65345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65346       };
65347     } catch (std::exception& e) {
65348       {
65349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65350       };
65351     } catch (Dali::DaliException e) {
65352       {
65353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65354       };
65355     } catch (...) {
65356       {
65357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65358       };
65359     }
65360   }
65361
65362   jresult = (void *)result;
65363   return jresult;
65364 }
65365
65366
65367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65368   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65369
65370   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65371   {
65372     try {
65373       delete arg1;
65374     } catch (std::out_of_range& e) {
65375       {
65376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65377       };
65378     } catch (std::exception& e) {
65379       {
65380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65381       };
65382     } catch (Dali::DaliException e) {
65383       {
65384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65385       };
65386     } catch (...) {
65387       {
65388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65389       };
65390     }
65391   }
65392
65393 }
65394
65395
65396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65397   void * jresult ;
65398   Dali::Toolkit::CheckBoxButton result;
65399
65400   {
65401     try {
65402       result = Dali::Toolkit::CheckBoxButton::New();
65403     } catch (std::out_of_range& e) {
65404       {
65405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65406       };
65407     } catch (std::exception& e) {
65408       {
65409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65410       };
65411     } catch (Dali::DaliException e) {
65412       {
65413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65414       };
65415     } catch (...) {
65416       {
65417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65418       };
65419     }
65420   }
65421
65422   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65423   return jresult;
65424 }
65425
65426
65427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65428   void * jresult ;
65429   Dali::BaseHandle arg1 ;
65430   Dali::BaseHandle *argp1 ;
65431   Dali::Toolkit::CheckBoxButton result;
65432
65433   argp1 = (Dali::BaseHandle *)jarg1;
65434   if (!argp1) {
65435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65436     return 0;
65437   }
65438   arg1 = *argp1;
65439   {
65440     try {
65441       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65442     } catch (std::out_of_range& e) {
65443       {
65444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65445       };
65446     } catch (std::exception& e) {
65447       {
65448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65449       };
65450     } catch (Dali::DaliException e) {
65451       {
65452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65453       };
65454     } catch (...) {
65455       {
65456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65457       };
65458     }
65459   }
65460
65461   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65462   return jresult;
65463 }
65464
65465
65466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
65467   int jresult ;
65468   int result;
65469
65470   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65471   jresult = (int)result;
65472   return jresult;
65473 }
65474
65475
65476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
65477   int jresult ;
65478   int result;
65479
65480   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65481   jresult = (int)result;
65482   return jresult;
65483 }
65484
65485
65486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
65487   void * jresult ;
65488   Dali::Toolkit::PushButton::Property *result = 0 ;
65489
65490   {
65491     try {
65492       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65493     } catch (std::out_of_range& e) {
65494       {
65495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65496       };
65497     } catch (std::exception& e) {
65498       {
65499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65500       };
65501     } catch (Dali::DaliException e) {
65502       {
65503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65504       };
65505     } catch (...) {
65506       {
65507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65508       };
65509     }
65510   }
65511
65512   jresult = (void *)result;
65513   return jresult;
65514 }
65515
65516
65517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
65518   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65519
65520   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65521   {
65522     try {
65523       delete arg1;
65524     } catch (std::out_of_range& e) {
65525       {
65526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65527       };
65528     } catch (std::exception& e) {
65529       {
65530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65531       };
65532     } catch (Dali::DaliException e) {
65533       {
65534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65535       };
65536     } catch (...) {
65537       {
65538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65539       };
65540     }
65541   }
65542
65543 }
65544
65545
65546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65547   void * jresult ;
65548   Dali::Toolkit::PushButton *result = 0 ;
65549
65550   {
65551     try {
65552       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65553     } catch (std::out_of_range& e) {
65554       {
65555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65556       };
65557     } catch (std::exception& e) {
65558       {
65559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65560       };
65561     } catch (Dali::DaliException e) {
65562       {
65563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65564       };
65565     } catch (...) {
65566       {
65567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65568       };
65569     }
65570   }
65571
65572   jresult = (void *)result;
65573   return jresult;
65574 }
65575
65576
65577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
65578   void * jresult ;
65579   Dali::Toolkit::PushButton *arg1 = 0 ;
65580   Dali::Toolkit::PushButton *result = 0 ;
65581
65582   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65583   if (!arg1) {
65584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65585     return 0;
65586   }
65587   {
65588     try {
65589       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65590     } catch (std::out_of_range& e) {
65591       {
65592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65593       };
65594     } catch (std::exception& e) {
65595       {
65596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65597       };
65598     } catch (Dali::DaliException e) {
65599       {
65600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65601       };
65602     } catch (...) {
65603       {
65604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65605       };
65606     }
65607   }
65608
65609   jresult = (void *)result;
65610   return jresult;
65611 }
65612
65613
65614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
65615   void * jresult ;
65616   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65617   Dali::Toolkit::PushButton *arg2 = 0 ;
65618   Dali::Toolkit::PushButton *result = 0 ;
65619
65620   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65621   arg2 = (Dali::Toolkit::PushButton *)jarg2;
65622   if (!arg2) {
65623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65624     return 0;
65625   }
65626   {
65627     try {
65628       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
65629     } catch (std::out_of_range& e) {
65630       {
65631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65632       };
65633     } catch (std::exception& e) {
65634       {
65635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65636       };
65637     } catch (Dali::DaliException e) {
65638       {
65639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65640       };
65641     } catch (...) {
65642       {
65643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65644       };
65645     }
65646   }
65647
65648   jresult = (void *)result;
65649   return jresult;
65650 }
65651
65652
65653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
65654   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65655
65656   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65657   {
65658     try {
65659       delete arg1;
65660     } catch (std::out_of_range& e) {
65661       {
65662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65663       };
65664     } catch (std::exception& e) {
65665       {
65666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65667       };
65668     } catch (Dali::DaliException e) {
65669       {
65670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65671       };
65672     } catch (...) {
65673       {
65674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65675       };
65676     }
65677   }
65678
65679 }
65680
65681
65682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
65683   void * jresult ;
65684   Dali::Toolkit::PushButton result;
65685
65686   {
65687     try {
65688       result = Dali::Toolkit::PushButton::New();
65689     } catch (std::out_of_range& e) {
65690       {
65691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65692       };
65693     } catch (std::exception& e) {
65694       {
65695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65696       };
65697     } catch (Dali::DaliException e) {
65698       {
65699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65700       };
65701     } catch (...) {
65702       {
65703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65704       };
65705     }
65706   }
65707
65708   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65709   return jresult;
65710 }
65711
65712
65713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65714   void * jresult ;
65715   Dali::BaseHandle arg1 ;
65716   Dali::BaseHandle *argp1 ;
65717   Dali::Toolkit::PushButton result;
65718
65719   argp1 = (Dali::BaseHandle *)jarg1;
65720   if (!argp1) {
65721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65722     return 0;
65723   }
65724   arg1 = *argp1;
65725   {
65726     try {
65727       result = Dali::Toolkit::PushButton::DownCast(arg1);
65728     } catch (std::out_of_range& e) {
65729       {
65730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65731       };
65732     } catch (std::exception& e) {
65733       {
65734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65735       };
65736     } catch (Dali::DaliException e) {
65737       {
65738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65739       };
65740     } catch (...) {
65741       {
65742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65743       };
65744     }
65745   }
65746
65747   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65748   return jresult;
65749 }
65750
65751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65752   void * jresult ;
65753   Dali::Toolkit::RadioButton *result = 0 ;
65754
65755   {
65756     try {
65757       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65758     } catch (std::out_of_range& e) {
65759       {
65760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65761       };
65762     } catch (std::exception& e) {
65763       {
65764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65765       };
65766     } catch (Dali::DaliException e) {
65767       {
65768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65769       };
65770     } catch (...) {
65771       {
65772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65773       };
65774     }
65775   }
65776
65777   jresult = (void *)result;
65778   return jresult;
65779 }
65780
65781
65782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65783   void * jresult ;
65784   Dali::Toolkit::RadioButton *arg1 = 0 ;
65785   Dali::Toolkit::RadioButton *result = 0 ;
65786
65787   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65788   if (!arg1) {
65789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65790     return 0;
65791   }
65792   {
65793     try {
65794       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65795     } catch (std::out_of_range& e) {
65796       {
65797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65798       };
65799     } catch (std::exception& e) {
65800       {
65801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65802       };
65803     } catch (Dali::DaliException e) {
65804       {
65805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65806       };
65807     } catch (...) {
65808       {
65809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65810       };
65811     }
65812   }
65813
65814   jresult = (void *)result;
65815   return jresult;
65816 }
65817
65818
65819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65820   void * jresult ;
65821   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65822   Dali::Toolkit::RadioButton *arg2 = 0 ;
65823   Dali::Toolkit::RadioButton *result = 0 ;
65824
65825   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65826   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65827   if (!arg2) {
65828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65829     return 0;
65830   }
65831   {
65832     try {
65833       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65834     } catch (std::out_of_range& e) {
65835       {
65836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65837       };
65838     } catch (std::exception& e) {
65839       {
65840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65841       };
65842     } catch (Dali::DaliException e) {
65843       {
65844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65845       };
65846     } catch (...) {
65847       {
65848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65849       };
65850     }
65851   }
65852
65853   jresult = (void *)result;
65854   return jresult;
65855 }
65856
65857
65858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65859   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65860
65861   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65862   {
65863     try {
65864       delete arg1;
65865     } catch (std::out_of_range& e) {
65866       {
65867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65868       };
65869     } catch (std::exception& e) {
65870       {
65871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65872       };
65873     } catch (Dali::DaliException e) {
65874       {
65875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65876       };
65877     } catch (...) {
65878       {
65879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65880       };
65881     }
65882   }
65883
65884 }
65885
65886
65887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65888   void * jresult ;
65889   Dali::Toolkit::RadioButton result;
65890
65891   {
65892     try {
65893       result = Dali::Toolkit::RadioButton::New();
65894     } catch (std::out_of_range& e) {
65895       {
65896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65897       };
65898     } catch (std::exception& e) {
65899       {
65900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65901       };
65902     } catch (Dali::DaliException e) {
65903       {
65904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65905       };
65906     } catch (...) {
65907       {
65908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65909       };
65910     }
65911   }
65912
65913   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65914   return jresult;
65915 }
65916
65917
65918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
65919   void * jresult ;
65920   std::string *arg1 = 0 ;
65921   Dali::Toolkit::RadioButton result;
65922
65923   if (!jarg1) {
65924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65925     return 0;
65926   }
65927   std::string arg1_str(jarg1);
65928   arg1 = &arg1_str;
65929   {
65930     try {
65931       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
65932     } catch (std::out_of_range& e) {
65933       {
65934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65935       };
65936     } catch (std::exception& e) {
65937       {
65938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65939       };
65940     } catch (Dali::DaliException e) {
65941       {
65942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65943       };
65944     } catch (...) {
65945       {
65946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65947       };
65948     }
65949   }
65950
65951   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65952
65953   //argout typemap for const std::string&
65954
65955   return jresult;
65956 }
65957
65958
65959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
65960   void * jresult ;
65961   Dali::BaseHandle arg1 ;
65962   Dali::BaseHandle *argp1 ;
65963   Dali::Toolkit::RadioButton result;
65964
65965   argp1 = (Dali::BaseHandle *)jarg1;
65966   if (!argp1) {
65967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65968     return 0;
65969   }
65970   arg1 = *argp1;
65971   {
65972     try {
65973       result = Dali::Toolkit::RadioButton::DownCast(arg1);
65974     } catch (std::out_of_range& e) {
65975       {
65976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65977       };
65978     } catch (std::exception& e) {
65979       {
65980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65981       };
65982     } catch (Dali::DaliException e) {
65983       {
65984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65985       };
65986     } catch (...) {
65987       {
65988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65989       };
65990     }
65991   }
65992
65993   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65994   return jresult;
65995 }
65996
65997
65998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
65999   int jresult ;
66000   int result;
66001
66002   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
66003   jresult = (int)result;
66004   return jresult;
66005 }
66006
66007
66008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
66009   int jresult ;
66010   int result;
66011
66012   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
66013   jresult = (int)result;
66014   return jresult;
66015 }
66016
66017
66018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
66019   int jresult ;
66020   int result;
66021
66022   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
66023   jresult = (int)result;
66024   return jresult;
66025 }
66026
66027
66028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
66029   int jresult ;
66030   int result;
66031
66032   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
66033   jresult = (int)result;
66034   return jresult;
66035 }
66036
66037
66038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
66039   int jresult ;
66040   int result;
66041
66042   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66043   jresult = (int)result;
66044   return jresult;
66045 }
66046
66047
66048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
66049   int jresult ;
66050   int result;
66051
66052   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66053   jresult = (int)result;
66054   return jresult;
66055 }
66056
66057
66058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
66059   void * jresult ;
66060   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66061
66062   {
66063     try {
66064       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
66065     } catch (std::out_of_range& e) {
66066       {
66067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66068       };
66069     } catch (std::exception& e) {
66070       {
66071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66072       };
66073     } catch (Dali::DaliException e) {
66074       {
66075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66076       };
66077     } catch (...) {
66078       {
66079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66080       };
66081     }
66082   }
66083
66084   jresult = (void *)result;
66085   return jresult;
66086 }
66087
66088
66089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
66090   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66091
66092   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66093   {
66094     try {
66095       delete arg1;
66096     } catch (std::out_of_range& e) {
66097       {
66098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66099       };
66100     } catch (std::exception& e) {
66101       {
66102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66103       };
66104     } catch (Dali::DaliException e) {
66105       {
66106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66107       };
66108     } catch (...) {
66109       {
66110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66111       };
66112     }
66113   }
66114
66115 }
66116
66117
66118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66119   int jresult ;
66120   int result;
66121
66122   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66123   jresult = (int)result;
66124   return jresult;
66125 }
66126
66127
66128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66129   int jresult ;
66130   int result;
66131
66132   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66133   jresult = (int)result;
66134   return jresult;
66135 }
66136
66137
66138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66139   int jresult ;
66140   int result;
66141
66142   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66143   jresult = (int)result;
66144   return jresult;
66145 }
66146
66147
66148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66149   void * jresult ;
66150   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66151
66152   {
66153     try {
66154       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66155     } catch (std::out_of_range& e) {
66156       {
66157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66158       };
66159     } catch (std::exception& e) {
66160       {
66161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66162       };
66163     } catch (Dali::DaliException e) {
66164       {
66165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66166       };
66167     } catch (...) {
66168       {
66169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66170       };
66171     }
66172   }
66173
66174   jresult = (void *)result;
66175   return jresult;
66176 }
66177
66178
66179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66180   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66181
66182   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66183   {
66184     try {
66185       delete arg1;
66186     } catch (std::out_of_range& e) {
66187       {
66188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66189       };
66190     } catch (std::exception& e) {
66191       {
66192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66193       };
66194     } catch (Dali::DaliException e) {
66195       {
66196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66197       };
66198     } catch (...) {
66199       {
66200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66201       };
66202     }
66203   }
66204
66205 }
66206
66207
66208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66209   void * jresult ;
66210   Dali::Toolkit::FlexContainer *result = 0 ;
66211
66212   {
66213     try {
66214       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66215     } catch (std::out_of_range& e) {
66216       {
66217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66218       };
66219     } catch (std::exception& e) {
66220       {
66221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66222       };
66223     } catch (Dali::DaliException e) {
66224       {
66225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66226       };
66227     } catch (...) {
66228       {
66229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66230       };
66231     }
66232   }
66233
66234   jresult = (void *)result;
66235   return jresult;
66236 }
66237
66238
66239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66240   void * jresult ;
66241   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66242   Dali::Toolkit::FlexContainer *result = 0 ;
66243
66244   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66245   if (!arg1) {
66246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66247     return 0;
66248   }
66249   {
66250     try {
66251       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66252     } catch (std::out_of_range& e) {
66253       {
66254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66255       };
66256     } catch (std::exception& e) {
66257       {
66258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66259       };
66260     } catch (Dali::DaliException e) {
66261       {
66262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66263       };
66264     } catch (...) {
66265       {
66266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66267       };
66268     }
66269   }
66270
66271   jresult = (void *)result;
66272   return jresult;
66273 }
66274
66275
66276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66277   void * jresult ;
66278   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66279   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66280   Dali::Toolkit::FlexContainer *result = 0 ;
66281
66282   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66283   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66284   if (!arg2) {
66285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66286     return 0;
66287   }
66288   {
66289     try {
66290       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66291     } catch (std::out_of_range& e) {
66292       {
66293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66294       };
66295     } catch (std::exception& e) {
66296       {
66297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66298       };
66299     } catch (Dali::DaliException e) {
66300       {
66301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66302       };
66303     } catch (...) {
66304       {
66305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66306       };
66307     }
66308   }
66309
66310   jresult = (void *)result;
66311   return jresult;
66312 }
66313
66314
66315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
66316   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66317
66318   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66319   {
66320     try {
66321       delete arg1;
66322     } catch (std::out_of_range& e) {
66323       {
66324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66325       };
66326     } catch (std::exception& e) {
66327       {
66328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66329       };
66330     } catch (Dali::DaliException e) {
66331       {
66332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66333       };
66334     } catch (...) {
66335       {
66336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66337       };
66338     }
66339   }
66340
66341 }
66342
66343
66344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
66345   void * jresult ;
66346   Dali::Toolkit::FlexContainer result;
66347
66348   {
66349     try {
66350       result = Dali::Toolkit::FlexContainer::New();
66351     } catch (std::out_of_range& e) {
66352       {
66353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66354       };
66355     } catch (std::exception& e) {
66356       {
66357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66358       };
66359     } catch (Dali::DaliException e) {
66360       {
66361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66362       };
66363     } catch (...) {
66364       {
66365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66366       };
66367     }
66368   }
66369
66370   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66371   return jresult;
66372 }
66373
66374
66375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66376   void * jresult ;
66377   Dali::BaseHandle arg1 ;
66378   Dali::BaseHandle *argp1 ;
66379   Dali::Toolkit::FlexContainer result;
66380
66381   argp1 = (Dali::BaseHandle *)jarg1;
66382   if (!argp1) {
66383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66384     return 0;
66385   }
66386   arg1 = *argp1;
66387   {
66388     try {
66389       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66390     } catch (std::out_of_range& e) {
66391       {
66392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66393       };
66394     } catch (std::exception& e) {
66395       {
66396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66397       };
66398     } catch (Dali::DaliException e) {
66399       {
66400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66401       };
66402     } catch (...) {
66403       {
66404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66405       };
66406     }
66407   }
66408
66409   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66410   return jresult;
66411 }
66412
66413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
66414   int jresult ;
66415   int result;
66416
66417   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66418   jresult = (int)result;
66419   return jresult;
66420 }
66421
66422
66423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66424   int jresult ;
66425   int result;
66426
66427   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66428   jresult = (int)result;
66429   return jresult;
66430 }
66431
66432
66433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
66434   int jresult ;
66435   int result;
66436
66437   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66438   jresult = (int)result;
66439   return jresult;
66440 }
66441
66442
66443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
66444   void * jresult ;
66445   Dali::Toolkit::ImageView::Property *result = 0 ;
66446
66447   {
66448     try {
66449       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
66450     } catch (std::out_of_range& e) {
66451       {
66452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66453       };
66454     } catch (std::exception& e) {
66455       {
66456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66457       };
66458     } catch (Dali::DaliException e) {
66459       {
66460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66461       };
66462     } catch (...) {
66463       {
66464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66465       };
66466     }
66467   }
66468
66469   jresult = (void *)result;
66470   return jresult;
66471 }
66472
66473
66474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
66475   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66476
66477   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66478   {
66479     try {
66480       delete arg1;
66481     } catch (std::out_of_range& e) {
66482       {
66483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66484       };
66485     } catch (std::exception& e) {
66486       {
66487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66488       };
66489     } catch (Dali::DaliException e) {
66490       {
66491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66492       };
66493     } catch (...) {
66494       {
66495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66496       };
66497     }
66498   }
66499
66500 }
66501
66502
66503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66504   void * jresult ;
66505   Dali::Toolkit::ImageView *result = 0 ;
66506
66507   {
66508     try {
66509       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66510     } catch (std::out_of_range& e) {
66511       {
66512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66513       };
66514     } catch (std::exception& e) {
66515       {
66516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66517       };
66518     } catch (Dali::DaliException e) {
66519       {
66520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66521       };
66522     } catch (...) {
66523       {
66524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66525       };
66526     }
66527   }
66528
66529   jresult = (void *)result;
66530   return jresult;
66531 }
66532
66533
66534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66535   void * jresult ;
66536   Dali::Toolkit::ImageView result;
66537
66538   {
66539     try {
66540       result = Dali::Toolkit::ImageView::New();
66541     } catch (std::out_of_range& e) {
66542       {
66543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66544       };
66545     } catch (std::exception& e) {
66546       {
66547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66548       };
66549     } catch (Dali::DaliException e) {
66550       {
66551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66552       };
66553     } catch (...) {
66554       {
66555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66556       };
66557     }
66558   }
66559
66560   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66561   return jresult;
66562 }
66563
66564
66565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66566   void * jresult ;
66567   std::string *arg1 = 0 ;
66568   Dali::Toolkit::ImageView result;
66569
66570   if (!jarg1) {
66571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66572     return 0;
66573   }
66574   std::string arg1_str(jarg1);
66575   arg1 = &arg1_str;
66576   {
66577     try {
66578       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66579     } catch (std::out_of_range& e) {
66580       {
66581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66582       };
66583     } catch (std::exception& e) {
66584       {
66585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66586       };
66587     } catch (Dali::DaliException e) {
66588       {
66589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66590       };
66591     } catch (...) {
66592       {
66593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66594       };
66595     }
66596   }
66597
66598   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66599
66600   //argout typemap for const std::string&
66601
66602   return jresult;
66603 }
66604
66605
66606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66607   void * jresult ;
66608   std::string *arg1 = 0 ;
66609   Dali::ImageDimensions arg2 ;
66610   Dali::ImageDimensions *argp2 ;
66611   Dali::Toolkit::ImageView result;
66612
66613   if (!jarg1) {
66614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66615     return 0;
66616   }
66617   std::string arg1_str(jarg1);
66618   arg1 = &arg1_str;
66619   argp2 = (Dali::ImageDimensions *)jarg2;
66620   if (!argp2) {
66621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66622     return 0;
66623   }
66624   arg2 = *argp2;
66625   {
66626     try {
66627       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66628     } catch (std::out_of_range& e) {
66629       {
66630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66631       };
66632     } catch (std::exception& e) {
66633       {
66634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66635       };
66636     } catch (Dali::DaliException e) {
66637       {
66638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66639       };
66640     } catch (...) {
66641       {
66642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66643       };
66644     }
66645   }
66646
66647   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66648
66649   //argout typemap for const std::string&
66650
66651   return jresult;
66652 }
66653
66654
66655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66656   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66657
66658   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66659   {
66660     try {
66661       delete arg1;
66662     } catch (std::out_of_range& e) {
66663       {
66664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66665       };
66666     } catch (std::exception& e) {
66667       {
66668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66669       };
66670     } catch (Dali::DaliException e) {
66671       {
66672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66673       };
66674     } catch (...) {
66675       {
66676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66677       };
66678     }
66679   }
66680
66681 }
66682
66683
66684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66685   void * jresult ;
66686   Dali::Toolkit::ImageView *arg1 = 0 ;
66687   Dali::Toolkit::ImageView *result = 0 ;
66688
66689   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66690   if (!arg1) {
66691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66692     return 0;
66693   }
66694   {
66695     try {
66696       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66697     } catch (std::out_of_range& e) {
66698       {
66699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66700       };
66701     } catch (std::exception& e) {
66702       {
66703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66704       };
66705     } catch (Dali::DaliException e) {
66706       {
66707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66708       };
66709     } catch (...) {
66710       {
66711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66712       };
66713     }
66714   }
66715
66716   jresult = (void *)result;
66717   return jresult;
66718 }
66719
66720
66721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66722   void * jresult ;
66723   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66724   Dali::Toolkit::ImageView *arg2 = 0 ;
66725   Dali::Toolkit::ImageView *result = 0 ;
66726
66727   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66728   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66729   if (!arg2) {
66730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66731     return 0;
66732   }
66733   {
66734     try {
66735       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66736     } catch (std::out_of_range& e) {
66737       {
66738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66739       };
66740     } catch (std::exception& e) {
66741       {
66742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66743       };
66744     } catch (Dali::DaliException e) {
66745       {
66746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66747       };
66748     } catch (...) {
66749       {
66750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66751       };
66752     }
66753   }
66754
66755   jresult = (void *)result;
66756   return jresult;
66757 }
66758
66759
66760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
66761   void * jresult ;
66762   Dali::BaseHandle arg1 ;
66763   Dali::BaseHandle *argp1 ;
66764   Dali::Toolkit::ImageView result;
66765
66766   argp1 = (Dali::BaseHandle *)jarg1;
66767   if (!argp1) {
66768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66769     return 0;
66770   }
66771   arg1 = *argp1;
66772   {
66773     try {
66774       result = Dali::Toolkit::ImageView::DownCast(arg1);
66775     } catch (std::out_of_range& e) {
66776       {
66777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66778       };
66779     } catch (std::exception& e) {
66780       {
66781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66782       };
66783     } catch (Dali::DaliException e) {
66784       {
66785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66786       };
66787     } catch (...) {
66788       {
66789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66790       };
66791     }
66792   }
66793
66794   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66795   return jresult;
66796 }
66797
66798
66799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
66800   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66801   std::string *arg2 = 0 ;
66802
66803   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66804   if (!jarg2) {
66805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66806     return ;
66807   }
66808   std::string arg2_str(jarg2);
66809   arg2 = &arg2_str;
66810   {
66811     try {
66812       (arg1)->SetImage((std::string const &)*arg2);
66813     } catch (std::out_of_range& e) {
66814       {
66815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66816       };
66817     } catch (std::exception& e) {
66818       {
66819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66820       };
66821     } catch (Dali::DaliException e) {
66822       {
66823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66824       };
66825     } catch (...) {
66826       {
66827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66828       };
66829     }
66830   }
66831
66832
66833   //argout typemap for const std::string&
66834
66835 }
66836
66837
66838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66839   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66840   std::string *arg2 = 0 ;
66841   Dali::ImageDimensions arg3 ;
66842   Dali::ImageDimensions *argp3 ;
66843
66844   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66845   if (!jarg2) {
66846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66847     return ;
66848   }
66849   std::string arg2_str(jarg2);
66850   arg2 = &arg2_str;
66851   argp3 = (Dali::ImageDimensions *)jarg3;
66852   if (!argp3) {
66853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66854     return ;
66855   }
66856   arg3 = *argp3;
66857   {
66858     try {
66859       (arg1)->SetImage((std::string const &)*arg2,arg3);
66860     } catch (std::out_of_range& e) {
66861       {
66862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66863       };
66864     } catch (std::exception& e) {
66865       {
66866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66867       };
66868     } catch (Dali::DaliException e) {
66869       {
66870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66871       };
66872     } catch (...) {
66873       {
66874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66875       };
66876     }
66877   }
66878
66879
66880   //argout typemap for const std::string&
66881
66882 }
66883
66884
66885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66886   int jresult ;
66887   int result;
66888
66889   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66890   jresult = (int)result;
66891   return jresult;
66892 }
66893
66894
66895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66896   int jresult ;
66897   int result;
66898
66899   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66900   jresult = (int)result;
66901   return jresult;
66902 }
66903
66904
66905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66906   int jresult ;
66907   int result;
66908
66909   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66910   jresult = (int)result;
66911   return jresult;
66912 }
66913
66914
66915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66916   int jresult ;
66917   int result;
66918
66919   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
66920   jresult = (int)result;
66921   return jresult;
66922 }
66923
66924
66925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
66926   int jresult ;
66927   int result;
66928
66929   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
66930   jresult = (int)result;
66931   return jresult;
66932 }
66933
66934
66935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
66936   int jresult ;
66937   int result;
66938
66939   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
66940   jresult = (int)result;
66941   return jresult;
66942 }
66943
66944
66945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
66946   int jresult ;
66947   int result;
66948
66949   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
66950   jresult = (int)result;
66951   return jresult;
66952 }
66953
66954
66955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
66956   int jresult ;
66957   int result;
66958
66959   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
66960   jresult = (int)result;
66961   return jresult;
66962 }
66963
66964
66965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
66966   void * jresult ;
66967   Dali::Toolkit::Model3dView::Property *result = 0 ;
66968
66969   {
66970     try {
66971       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
66972     } catch (std::out_of_range& e) {
66973       {
66974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66975       };
66976     } catch (std::exception& e) {
66977       {
66978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66979       };
66980     } catch (Dali::DaliException e) {
66981       {
66982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66983       };
66984     } catch (...) {
66985       {
66986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66987       };
66988     }
66989   }
66990
66991   jresult = (void *)result;
66992   return jresult;
66993 }
66994
66995
66996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
66997   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
66998
66999   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
67000   {
67001     try {
67002       delete arg1;
67003     } catch (std::out_of_range& e) {
67004       {
67005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67006       };
67007     } catch (std::exception& e) {
67008       {
67009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67010       };
67011     } catch (Dali::DaliException e) {
67012       {
67013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67014       };
67015     } catch (...) {
67016       {
67017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67018       };
67019     }
67020   }
67021
67022 }
67023
67024
67025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
67026   void * jresult ;
67027   Dali::Toolkit::Model3dView result;
67028
67029   {
67030     try {
67031       result = Dali::Toolkit::Model3dView::New();
67032     } catch (std::out_of_range& e) {
67033       {
67034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67035       };
67036     } catch (std::exception& e) {
67037       {
67038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67039       };
67040     } catch (Dali::DaliException e) {
67041       {
67042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67043       };
67044     } catch (...) {
67045       {
67046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67047       };
67048     }
67049   }
67050
67051   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67052   return jresult;
67053 }
67054
67055
67056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67057   void * jresult ;
67058   std::string *arg1 = 0 ;
67059   std::string *arg2 = 0 ;
67060   std::string *arg3 = 0 ;
67061   Dali::Toolkit::Model3dView result;
67062
67063   if (!jarg1) {
67064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67065     return 0;
67066   }
67067   std::string arg1_str(jarg1);
67068   arg1 = &arg1_str;
67069   if (!jarg2) {
67070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67071     return 0;
67072   }
67073   std::string arg2_str(jarg2);
67074   arg2 = &arg2_str;
67075   if (!jarg3) {
67076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67077     return 0;
67078   }
67079   std::string arg3_str(jarg3);
67080   arg3 = &arg3_str;
67081   {
67082     try {
67083       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67084     } catch (std::out_of_range& e) {
67085       {
67086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67087       };
67088     } catch (std::exception& e) {
67089       {
67090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67091       };
67092     } catch (Dali::DaliException e) {
67093       {
67094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67095       };
67096     } catch (...) {
67097       {
67098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67099       };
67100     }
67101   }
67102
67103   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67104
67105   //argout typemap for const std::string&
67106
67107
67108   //argout typemap for const std::string&
67109
67110
67111   //argout typemap for const std::string&
67112
67113   return jresult;
67114 }
67115
67116
67117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67118   void * jresult ;
67119   Dali::Toolkit::Model3dView *result = 0 ;
67120
67121   {
67122     try {
67123       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67124     } catch (std::out_of_range& e) {
67125       {
67126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67127       };
67128     } catch (std::exception& e) {
67129       {
67130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67131       };
67132     } catch (Dali::DaliException e) {
67133       {
67134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67135       };
67136     } catch (...) {
67137       {
67138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67139       };
67140     }
67141   }
67142
67143   jresult = (void *)result;
67144   return jresult;
67145 }
67146
67147
67148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67149   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67150
67151   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67152   {
67153     try {
67154       delete arg1;
67155     } catch (std::out_of_range& e) {
67156       {
67157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67158       };
67159     } catch (std::exception& e) {
67160       {
67161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67162       };
67163     } catch (Dali::DaliException e) {
67164       {
67165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67166       };
67167     } catch (...) {
67168       {
67169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67170       };
67171     }
67172   }
67173
67174 }
67175
67176
67177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67178   void * jresult ;
67179   Dali::Toolkit::Model3dView *arg1 = 0 ;
67180   Dali::Toolkit::Model3dView *result = 0 ;
67181
67182   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67183   if (!arg1) {
67184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67185     return 0;
67186   }
67187   {
67188     try {
67189       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67190     } catch (std::out_of_range& e) {
67191       {
67192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67193       };
67194     } catch (std::exception& e) {
67195       {
67196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67197       };
67198     } catch (Dali::DaliException e) {
67199       {
67200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67201       };
67202     } catch (...) {
67203       {
67204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67205       };
67206     }
67207   }
67208
67209   jresult = (void *)result;
67210   return jresult;
67211 }
67212
67213
67214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67215   void * jresult ;
67216   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67217   Dali::Toolkit::Model3dView *arg2 = 0 ;
67218   Dali::Toolkit::Model3dView *result = 0 ;
67219
67220   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67221   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67222   if (!arg2) {
67223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67224     return 0;
67225   }
67226   {
67227     try {
67228       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67229     } catch (std::out_of_range& e) {
67230       {
67231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67232       };
67233     } catch (std::exception& e) {
67234       {
67235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67236       };
67237     } catch (Dali::DaliException e) {
67238       {
67239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67240       };
67241     } catch (...) {
67242       {
67243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67244       };
67245     }
67246   }
67247
67248   jresult = (void *)result;
67249   return jresult;
67250 }
67251
67252
67253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67254   void * jresult ;
67255   Dali::BaseHandle arg1 ;
67256   Dali::BaseHandle *argp1 ;
67257   Dali::Toolkit::Model3dView result;
67258
67259   argp1 = (Dali::BaseHandle *)jarg1;
67260   if (!argp1) {
67261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67262     return 0;
67263   }
67264   arg1 = *argp1;
67265   {
67266     try {
67267       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67268     } catch (std::out_of_range& e) {
67269       {
67270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67271       };
67272     } catch (std::exception& e) {
67273       {
67274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67275       };
67276     } catch (Dali::DaliException e) {
67277       {
67278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67279       };
67280     } catch (...) {
67281       {
67282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67283       };
67284     }
67285   }
67286
67287   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67288   return jresult;
67289 }
67290
67291
67292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67293   int jresult ;
67294   int result;
67295
67296   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67297   jresult = (int)result;
67298   return jresult;
67299 }
67300
67301
67302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67303   int jresult ;
67304   int result;
67305
67306   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67307   jresult = (int)result;
67308   return jresult;
67309 }
67310
67311
67312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67313   int jresult ;
67314   int result;
67315
67316   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67317   jresult = (int)result;
67318   return jresult;
67319 }
67320
67321
67322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67323   int jresult ;
67324   int result;
67325
67326   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67327   jresult = (int)result;
67328   return jresult;
67329 }
67330
67331
67332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67333   int jresult ;
67334   int result;
67335
67336   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67337   jresult = (int)result;
67338   return jresult;
67339 }
67340
67341
67342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67343   int jresult ;
67344   int result;
67345
67346   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67347   jresult = (int)result;
67348   return jresult;
67349 }
67350
67351
67352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67353   int jresult ;
67354   int result;
67355
67356   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67357   jresult = (int)result;
67358   return jresult;
67359 }
67360
67361
67362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67363   int jresult ;
67364   int result;
67365
67366   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67367   jresult = (int)result;
67368   return jresult;
67369 }
67370
67371
67372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67373   int jresult ;
67374   int result;
67375
67376   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67377   jresult = (int)result;
67378   return jresult;
67379 }
67380
67381
67382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67383   void * jresult ;
67384   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67385
67386   {
67387     try {
67388       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67389     } catch (std::out_of_range& e) {
67390       {
67391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67392       };
67393     } catch (std::exception& e) {
67394       {
67395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67396       };
67397     } catch (Dali::DaliException e) {
67398       {
67399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67400       };
67401     } catch (...) {
67402       {
67403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67404       };
67405     }
67406   }
67407
67408   jresult = (void *)result;
67409   return jresult;
67410 }
67411
67412
67413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67414   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67415
67416   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67417   {
67418     try {
67419       delete arg1;
67420     } catch (std::out_of_range& e) {
67421       {
67422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67423       };
67424     } catch (std::exception& e) {
67425       {
67426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67427       };
67428     } catch (Dali::DaliException e) {
67429       {
67430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67431       };
67432     } catch (...) {
67433       {
67434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67435       };
67436     }
67437   }
67438
67439 }
67440
67441
67442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
67443   void * jresult ;
67444   Dali::Toolkit::ScrollBar *result = 0 ;
67445
67446   {
67447     try {
67448       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67449     } catch (std::out_of_range& e) {
67450       {
67451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67452       };
67453     } catch (std::exception& e) {
67454       {
67455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67456       };
67457     } catch (Dali::DaliException e) {
67458       {
67459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67460       };
67461     } catch (...) {
67462       {
67463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67464       };
67465     }
67466   }
67467
67468   jresult = (void *)result;
67469   return jresult;
67470 }
67471
67472
67473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
67474   void * jresult ;
67475   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67476   Dali::Toolkit::ScrollBar *result = 0 ;
67477
67478   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67479   if (!arg1) {
67480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67481     return 0;
67482   }
67483   {
67484     try {
67485       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
67486     } catch (std::out_of_range& e) {
67487       {
67488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67489       };
67490     } catch (std::exception& e) {
67491       {
67492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67493       };
67494     } catch (Dali::DaliException e) {
67495       {
67496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67497       };
67498     } catch (...) {
67499       {
67500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67501       };
67502     }
67503   }
67504
67505   jresult = (void *)result;
67506   return jresult;
67507 }
67508
67509
67510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
67511   void * jresult ;
67512   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67513   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67514   Dali::Toolkit::ScrollBar *result = 0 ;
67515
67516   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67517   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67518   if (!arg2) {
67519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67520     return 0;
67521   }
67522   {
67523     try {
67524       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67525     } catch (std::out_of_range& e) {
67526       {
67527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67528       };
67529     } catch (std::exception& e) {
67530       {
67531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67532       };
67533     } catch (Dali::DaliException e) {
67534       {
67535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67536       };
67537     } catch (...) {
67538       {
67539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67540       };
67541     }
67542   }
67543
67544   jresult = (void *)result;
67545   return jresult;
67546 }
67547
67548
67549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67550   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67551
67552   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67553   {
67554     try {
67555       delete arg1;
67556     } catch (std::out_of_range& e) {
67557       {
67558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67559       };
67560     } catch (std::exception& e) {
67561       {
67562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67563       };
67564     } catch (Dali::DaliException e) {
67565       {
67566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67567       };
67568     } catch (...) {
67569       {
67570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67571       };
67572     }
67573   }
67574
67575 }
67576
67577
67578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67579   void * jresult ;
67580   Dali::Toolkit::ScrollBar::Direction arg1 ;
67581   Dali::Toolkit::ScrollBar result;
67582
67583   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67584   {
67585     try {
67586       result = Dali::Toolkit::ScrollBar::New(arg1);
67587     } catch (std::out_of_range& e) {
67588       {
67589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67590       };
67591     } catch (std::exception& e) {
67592       {
67593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67594       };
67595     } catch (Dali::DaliException e) {
67596       {
67597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67598       };
67599     } catch (...) {
67600       {
67601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67602       };
67603     }
67604   }
67605
67606   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67607   return jresult;
67608 }
67609
67610
67611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67612   void * jresult ;
67613   Dali::Toolkit::ScrollBar result;
67614
67615   {
67616     try {
67617       result = Dali::Toolkit::ScrollBar::New();
67618     } catch (std::out_of_range& e) {
67619       {
67620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67621       };
67622     } catch (std::exception& e) {
67623       {
67624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67625       };
67626     } catch (Dali::DaliException e) {
67627       {
67628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67629       };
67630     } catch (...) {
67631       {
67632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67633       };
67634     }
67635   }
67636
67637   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67638   return jresult;
67639 }
67640
67641
67642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67643   void * jresult ;
67644   Dali::BaseHandle arg1 ;
67645   Dali::BaseHandle *argp1 ;
67646   Dali::Toolkit::ScrollBar result;
67647
67648   argp1 = (Dali::BaseHandle *)jarg1;
67649   if (!argp1) {
67650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67651     return 0;
67652   }
67653   arg1 = *argp1;
67654   {
67655     try {
67656       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67657     } catch (std::out_of_range& e) {
67658       {
67659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67660       };
67661     } catch (std::exception& e) {
67662       {
67663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67664       };
67665     } catch (Dali::DaliException e) {
67666       {
67667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67668       };
67669     } catch (...) {
67670       {
67671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67672       };
67673     }
67674   }
67675
67676   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67677   return jresult;
67678 }
67679
67680
67681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67682   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67683   Dali::Handle arg2 ;
67684   Dali::Property::Index arg3 ;
67685   Dali::Property::Index arg4 ;
67686   Dali::Property::Index arg5 ;
67687   Dali::Property::Index arg6 ;
67688   Dali::Handle *argp2 ;
67689
67690   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67691   argp2 = (Dali::Handle *)jarg2;
67692   if (!argp2) {
67693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67694     return ;
67695   }
67696   arg2 = *argp2;
67697   arg3 = (Dali::Property::Index)jarg3;
67698   arg4 = (Dali::Property::Index)jarg4;
67699   arg5 = (Dali::Property::Index)jarg5;
67700   arg6 = (Dali::Property::Index)jarg6;
67701   {
67702     try {
67703       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67704     } catch (std::out_of_range& e) {
67705       {
67706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67707       };
67708     } catch (std::exception& e) {
67709       {
67710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67711       };
67712     } catch (Dali::DaliException e) {
67713       {
67714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67715       };
67716     } catch (...) {
67717       {
67718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67719       };
67720     }
67721   }
67722
67723 }
67724
67725
67726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67727   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67728   Dali::Actor arg2 ;
67729   Dali::Actor *argp2 ;
67730
67731   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67732   argp2 = (Dali::Actor *)jarg2;
67733   if (!argp2) {
67734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67735     return ;
67736   }
67737   arg2 = *argp2;
67738   {
67739     try {
67740       (arg1)->SetScrollIndicator(arg2);
67741     } catch (std::out_of_range& e) {
67742       {
67743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67744       };
67745     } catch (std::exception& e) {
67746       {
67747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67748       };
67749     } catch (Dali::DaliException e) {
67750       {
67751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67752       };
67753     } catch (...) {
67754       {
67755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67756       };
67757     }
67758   }
67759
67760 }
67761
67762
67763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
67764   void * jresult ;
67765   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67766   Dali::Actor result;
67767
67768   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67769   {
67770     try {
67771       result = (arg1)->GetScrollIndicator();
67772     } catch (std::out_of_range& e) {
67773       {
67774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67775       };
67776     } catch (std::exception& e) {
67777       {
67778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67779       };
67780     } catch (Dali::DaliException e) {
67781       {
67782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67783       };
67784     } catch (...) {
67785       {
67786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67787       };
67788     }
67789   }
67790
67791   jresult = new Dali::Actor((const Dali::Actor &)result);
67792   return jresult;
67793 }
67794
67795
67796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
67797   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67798   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
67799
67800   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67801   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
67802   if (!arg2) {
67803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
67804     return ;
67805   }
67806   {
67807     try {
67808       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
67809     } catch (std::out_of_range& e) {
67810       {
67811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67812       };
67813     } catch (std::exception& e) {
67814       {
67815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67816       };
67817     } catch (Dali::DaliException e) {
67818       {
67819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67820       };
67821     } catch (...) {
67822       {
67823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67824       };
67825     }
67826   }
67827
67828 }
67829
67830
67831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
67832   void * jresult ;
67833   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67834
67835   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67836   {
67837     try {
67838       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()));
67839     } catch (std::out_of_range& e) {
67840       {
67841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67842       };
67843     } catch (std::exception& e) {
67844       {
67845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67846       };
67847     } catch (...) {
67848       {
67849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67850       };
67851     }
67852   }
67853   return jresult;
67854 }
67855
67856
67857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
67858   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67859   Dali::Toolkit::ScrollBar::Direction arg2 ;
67860
67861   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67862   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
67863   {
67864     try {
67865       (arg1)->SetScrollDirection(arg2);
67866     } catch (std::out_of_range& e) {
67867       {
67868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67869       };
67870     } catch (std::exception& e) {
67871       {
67872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67873       };
67874     } catch (Dali::DaliException e) {
67875       {
67876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67877       };
67878     } catch (...) {
67879       {
67880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67881       };
67882     }
67883   }
67884
67885 }
67886
67887
67888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
67889   int jresult ;
67890   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67891   Dali::Toolkit::ScrollBar::Direction result;
67892
67893   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67894   {
67895     try {
67896       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
67897     } catch (std::out_of_range& e) {
67898       {
67899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67900       };
67901     } catch (std::exception& e) {
67902       {
67903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67904       };
67905     } catch (Dali::DaliException e) {
67906       {
67907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67908       };
67909     } catch (...) {
67910       {
67911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67912       };
67913     }
67914   }
67915
67916   jresult = (int)result;
67917   return jresult;
67918 }
67919
67920
67921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
67922   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67923   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
67924
67925   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67926   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
67927   {
67928     try {
67929       (arg1)->SetIndicatorHeightPolicy(arg2);
67930     } catch (std::out_of_range& e) {
67931       {
67932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67933       };
67934     } catch (std::exception& e) {
67935       {
67936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67937       };
67938     } catch (Dali::DaliException e) {
67939       {
67940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67941       };
67942     } catch (...) {
67943       {
67944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67945       };
67946     }
67947   }
67948
67949 }
67950
67951
67952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
67953   int jresult ;
67954   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67955   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
67956
67957   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67958   {
67959     try {
67960       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
67961     } catch (std::out_of_range& e) {
67962       {
67963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67964       };
67965     } catch (std::exception& e) {
67966       {
67967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67968       };
67969     } catch (Dali::DaliException e) {
67970       {
67971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67972       };
67973     } catch (...) {
67974       {
67975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67976       };
67977     }
67978   }
67979
67980   jresult = (int)result;
67981   return jresult;
67982 }
67983
67984
67985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
67986   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67987   float arg2 ;
67988
67989   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67990   arg2 = (float)jarg2;
67991   {
67992     try {
67993       (arg1)->SetIndicatorFixedHeight(arg2);
67994     } catch (std::out_of_range& e) {
67995       {
67996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67997       };
67998     } catch (std::exception& e) {
67999       {
68000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68001       };
68002     } catch (Dali::DaliException e) {
68003       {
68004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68005       };
68006     } catch (...) {
68007       {
68008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68009       };
68010     }
68011   }
68012
68013 }
68014
68015
68016 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
68017   float jresult ;
68018   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68019   float result;
68020
68021   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68022   {
68023     try {
68024       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
68025     } catch (std::out_of_range& e) {
68026       {
68027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68028       };
68029     } catch (std::exception& e) {
68030       {
68031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68032       };
68033     } catch (Dali::DaliException e) {
68034       {
68035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68036       };
68037     } catch (...) {
68038       {
68039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68040       };
68041     }
68042   }
68043
68044   jresult = result;
68045   return jresult;
68046 }
68047
68048
68049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
68050   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68051   float arg2 ;
68052
68053   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68054   arg2 = (float)jarg2;
68055   {
68056     try {
68057       (arg1)->SetIndicatorShowDuration(arg2);
68058     } catch (std::out_of_range& e) {
68059       {
68060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68061       };
68062     } catch (std::exception& e) {
68063       {
68064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68065       };
68066     } catch (Dali::DaliException e) {
68067       {
68068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68069       };
68070     } catch (...) {
68071       {
68072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68073       };
68074     }
68075   }
68076
68077 }
68078
68079
68080 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68081   float jresult ;
68082   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68083   float result;
68084
68085   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68086   {
68087     try {
68088       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
68089     } catch (std::out_of_range& e) {
68090       {
68091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68092       };
68093     } catch (std::exception& e) {
68094       {
68095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68096       };
68097     } catch (Dali::DaliException e) {
68098       {
68099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68100       };
68101     } catch (...) {
68102       {
68103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68104       };
68105     }
68106   }
68107
68108   jresult = result;
68109   return jresult;
68110 }
68111
68112
68113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68114   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68115   float arg2 ;
68116
68117   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68118   arg2 = (float)jarg2;
68119   {
68120     try {
68121       (arg1)->SetIndicatorHideDuration(arg2);
68122     } catch (std::out_of_range& e) {
68123       {
68124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68125       };
68126     } catch (std::exception& e) {
68127       {
68128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68129       };
68130     } catch (Dali::DaliException e) {
68131       {
68132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68133       };
68134     } catch (...) {
68135       {
68136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68137       };
68138     }
68139   }
68140
68141 }
68142
68143
68144 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68145   float jresult ;
68146   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68147   float result;
68148
68149   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68150   {
68151     try {
68152       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68153     } catch (std::out_of_range& e) {
68154       {
68155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68156       };
68157     } catch (std::exception& e) {
68158       {
68159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68160       };
68161     } catch (Dali::DaliException e) {
68162       {
68163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68164       };
68165     } catch (...) {
68166       {
68167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68168       };
68169     }
68170   }
68171
68172   jresult = result;
68173   return jresult;
68174 }
68175
68176
68177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68178   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68179
68180   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68181   {
68182     try {
68183       (arg1)->ShowIndicator();
68184     } catch (std::out_of_range& e) {
68185       {
68186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68187       };
68188     } catch (std::exception& e) {
68189       {
68190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68191       };
68192     } catch (Dali::DaliException e) {
68193       {
68194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68195       };
68196     } catch (...) {
68197       {
68198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68199       };
68200     }
68201   }
68202
68203 }
68204
68205
68206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68207   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68208
68209   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68210   {
68211     try {
68212       (arg1)->HideIndicator();
68213     } catch (std::out_of_range& e) {
68214       {
68215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68216       };
68217     } catch (std::exception& e) {
68218       {
68219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68220       };
68221     } catch (Dali::DaliException e) {
68222       {
68223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68224       };
68225     } catch (...) {
68226       {
68227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68228       };
68229     }
68230   }
68231
68232 }
68233
68234
68235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68236   void * jresult ;
68237   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68238   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68239
68240   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68241   {
68242     try {
68243       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68244     } catch (std::out_of_range& e) {
68245       {
68246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68247       };
68248     } catch (std::exception& e) {
68249       {
68250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68251       };
68252     } catch (Dali::DaliException e) {
68253       {
68254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68255       };
68256     } catch (...) {
68257       {
68258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68259       };
68260     }
68261   }
68262
68263   jresult = (void *)result;
68264   return jresult;
68265 }
68266
68267
68268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68269   void * jresult ;
68270   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68271   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68272
68273   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68274   {
68275     try {
68276       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68277     } catch (std::out_of_range& e) {
68278       {
68279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68280       };
68281     } catch (std::exception& e) {
68282       {
68283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68284       };
68285     } catch (Dali::DaliException e) {
68286       {
68287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68288       };
68289     } catch (...) {
68290       {
68291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68292       };
68293     }
68294   }
68295
68296   jresult = (void *)result;
68297   return jresult;
68298 }
68299
68300
68301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68302   int jresult ;
68303   int result;
68304
68305   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68306   jresult = (int)result;
68307   return jresult;
68308 }
68309
68310
68311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68312   int jresult ;
68313   int result;
68314
68315   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68316   jresult = (int)result;
68317   return jresult;
68318 }
68319
68320
68321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68322   int jresult ;
68323   int result;
68324
68325   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68326   jresult = (int)result;
68327   return jresult;
68328 }
68329
68330
68331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68332   int jresult ;
68333   int result;
68334
68335   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68336   jresult = (int)result;
68337   return jresult;
68338 }
68339
68340
68341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68342   int jresult ;
68343   int result;
68344
68345   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68346   jresult = (int)result;
68347   return jresult;
68348 }
68349
68350
68351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68352   int jresult ;
68353   int result;
68354
68355   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68356   jresult = (int)result;
68357   return jresult;
68358 }
68359
68360
68361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68362   int jresult ;
68363   int result;
68364
68365   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68366   jresult = (int)result;
68367   return jresult;
68368 }
68369
68370
68371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68372   int jresult ;
68373   int result;
68374
68375   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68376   jresult = (int)result;
68377   return jresult;
68378 }
68379
68380
68381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68382   int jresult ;
68383   int result;
68384
68385   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68386   jresult = (int)result;
68387   return jresult;
68388 }
68389
68390
68391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68392   int jresult ;
68393   int result;
68394
68395   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68396   jresult = (int)result;
68397   return jresult;
68398 }
68399
68400
68401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68402   int jresult ;
68403   int result;
68404
68405   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68406   jresult = (int)result;
68407   return jresult;
68408 }
68409
68410
68411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68412   int jresult ;
68413   int result;
68414
68415   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68416   jresult = (int)result;
68417   return jresult;
68418 }
68419
68420
68421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68422   int jresult ;
68423   int result;
68424
68425   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68426   jresult = (int)result;
68427   return jresult;
68428 }
68429
68430
68431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68432   int jresult ;
68433   int result;
68434
68435   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68436   jresult = (int)result;
68437   return jresult;
68438 }
68439
68440
68441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
68442   void * jresult ;
68443   Dali::Toolkit::Scrollable::Property *result = 0 ;
68444
68445   {
68446     try {
68447       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68448     } catch (std::out_of_range& e) {
68449       {
68450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68451       };
68452     } catch (std::exception& e) {
68453       {
68454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68455       };
68456     } catch (Dali::DaliException e) {
68457       {
68458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68459       };
68460     } catch (...) {
68461       {
68462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68463       };
68464     }
68465   }
68466
68467   jresult = (void *)result;
68468   return jresult;
68469 }
68470
68471
68472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
68473   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68474
68475   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68476   {
68477     try {
68478       delete arg1;
68479     } catch (std::out_of_range& e) {
68480       {
68481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68482       };
68483     } catch (std::exception& e) {
68484       {
68485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68486       };
68487     } catch (Dali::DaliException e) {
68488       {
68489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68490       };
68491     } catch (...) {
68492       {
68493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68494       };
68495     }
68496   }
68497
68498 }
68499
68500
68501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68502   void * jresult ;
68503   Dali::Toolkit::Scrollable *result = 0 ;
68504
68505   {
68506     try {
68507       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68508     } catch (std::out_of_range& e) {
68509       {
68510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68511       };
68512     } catch (std::exception& e) {
68513       {
68514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68515       };
68516     } catch (Dali::DaliException e) {
68517       {
68518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68519       };
68520     } catch (...) {
68521       {
68522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68523       };
68524     }
68525   }
68526
68527   jresult = (void *)result;
68528   return jresult;
68529 }
68530
68531
68532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68533   void * jresult ;
68534   Dali::Toolkit::Scrollable *arg1 = 0 ;
68535   Dali::Toolkit::Scrollable *result = 0 ;
68536
68537   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68538   if (!arg1) {
68539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68540     return 0;
68541   }
68542   {
68543     try {
68544       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68545     } catch (std::out_of_range& e) {
68546       {
68547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68548       };
68549     } catch (std::exception& e) {
68550       {
68551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68552       };
68553     } catch (Dali::DaliException e) {
68554       {
68555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68556       };
68557     } catch (...) {
68558       {
68559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68560       };
68561     }
68562   }
68563
68564   jresult = (void *)result;
68565   return jresult;
68566 }
68567
68568
68569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
68570   void * jresult ;
68571   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68572   Dali::Toolkit::Scrollable *arg2 = 0 ;
68573   Dali::Toolkit::Scrollable *result = 0 ;
68574
68575   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68576   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
68577   if (!arg2) {
68578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68579     return 0;
68580   }
68581   {
68582     try {
68583       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
68584     } catch (std::out_of_range& e) {
68585       {
68586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68587       };
68588     } catch (std::exception& e) {
68589       {
68590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68591       };
68592     } catch (Dali::DaliException e) {
68593       {
68594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68595       };
68596     } catch (...) {
68597       {
68598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68599       };
68600     }
68601   }
68602
68603   jresult = (void *)result;
68604   return jresult;
68605 }
68606
68607
68608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
68609   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68610
68611   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68612   {
68613     try {
68614       delete arg1;
68615     } catch (std::out_of_range& e) {
68616       {
68617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68618       };
68619     } catch (std::exception& e) {
68620       {
68621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68622       };
68623     } catch (Dali::DaliException e) {
68624       {
68625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68626       };
68627     } catch (...) {
68628       {
68629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68630       };
68631     }
68632   }
68633
68634 }
68635
68636
68637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
68638   void * jresult ;
68639   Dali::BaseHandle arg1 ;
68640   Dali::BaseHandle *argp1 ;
68641   Dali::Toolkit::Scrollable result;
68642
68643   argp1 = (Dali::BaseHandle *)jarg1;
68644   if (!argp1) {
68645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68646     return 0;
68647   }
68648   arg1 = *argp1;
68649   {
68650     try {
68651       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68652     } catch (std::out_of_range& e) {
68653       {
68654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68655       };
68656     } catch (std::exception& e) {
68657       {
68658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68659       };
68660     } catch (Dali::DaliException e) {
68661       {
68662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68663       };
68664     } catch (...) {
68665       {
68666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68667       };
68668     }
68669   }
68670
68671   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68672   return jresult;
68673 }
68674
68675
68676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68677   unsigned int jresult ;
68678   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68679   bool result;
68680
68681   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68682   {
68683     try {
68684       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68685     } catch (std::out_of_range& e) {
68686       {
68687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68688       };
68689     } catch (std::exception& e) {
68690       {
68691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68692       };
68693     } catch (Dali::DaliException e) {
68694       {
68695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68696       };
68697     } catch (...) {
68698       {
68699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68700       };
68701     }
68702   }
68703
68704   jresult = result;
68705   return jresult;
68706 }
68707
68708
68709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68710   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68711   bool arg2 ;
68712
68713   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68714   arg2 = jarg2 ? true : false;
68715   {
68716     try {
68717       (arg1)->SetOvershootEnabled(arg2);
68718     } catch (std::out_of_range& e) {
68719       {
68720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68721       };
68722     } catch (std::exception& e) {
68723       {
68724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68725       };
68726     } catch (Dali::DaliException e) {
68727       {
68728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68729       };
68730     } catch (...) {
68731       {
68732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68733       };
68734     }
68735   }
68736
68737 }
68738
68739
68740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68741   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68742   Dali::Vector4 *arg2 = 0 ;
68743
68744   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68745   arg2 = (Dali::Vector4 *)jarg2;
68746   if (!arg2) {
68747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68748     return ;
68749   }
68750   {
68751     try {
68752       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68753     } catch (std::out_of_range& e) {
68754       {
68755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68756       };
68757     } catch (std::exception& e) {
68758       {
68759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68760       };
68761     } catch (Dali::DaliException e) {
68762       {
68763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68764       };
68765     } catch (...) {
68766       {
68767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68768       };
68769     }
68770   }
68771
68772 }
68773
68774
68775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
68776   void * jresult ;
68777   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68778   Dali::Vector4 result;
68779
68780   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68781   {
68782     try {
68783       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68784     } catch (std::out_of_range& e) {
68785       {
68786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68787       };
68788     } catch (std::exception& e) {
68789       {
68790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68791       };
68792     } catch (Dali::DaliException e) {
68793       {
68794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68795       };
68796     } catch (...) {
68797       {
68798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68799       };
68800     }
68801   }
68802
68803   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68804   return jresult;
68805 }
68806
68807
68808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68809   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68810   float arg2 ;
68811
68812   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68813   arg2 = (float)jarg2;
68814   {
68815     try {
68816       (arg1)->SetOvershootAnimationSpeed(arg2);
68817     } catch (std::out_of_range& e) {
68818       {
68819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68820       };
68821     } catch (std::exception& e) {
68822       {
68823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68824       };
68825     } catch (Dali::DaliException e) {
68826       {
68827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68828       };
68829     } catch (...) {
68830       {
68831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68832       };
68833     }
68834   }
68835
68836 }
68837
68838
68839 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
68840   float jresult ;
68841   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68842   float result;
68843
68844   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68845   {
68846     try {
68847       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
68848     } catch (std::out_of_range& e) {
68849       {
68850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68851       };
68852     } catch (std::exception& e) {
68853       {
68854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68855       };
68856     } catch (Dali::DaliException e) {
68857       {
68858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68859       };
68860     } catch (...) {
68861       {
68862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68863       };
68864     }
68865   }
68866
68867   jresult = result;
68868   return jresult;
68869 }
68870
68871
68872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
68873   void * jresult ;
68874   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68875   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
68876
68877   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68878   {
68879     try {
68880       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
68881     } catch (std::out_of_range& e) {
68882       {
68883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68884       };
68885     } catch (std::exception& e) {
68886       {
68887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68888       };
68889     } catch (Dali::DaliException e) {
68890       {
68891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68892       };
68893     } catch (...) {
68894       {
68895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68896       };
68897     }
68898   }
68899
68900   jresult = (void *)result;
68901   return jresult;
68902 }
68903
68904
68905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
68906   void * jresult ;
68907   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68908   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
68909
68910   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68911   {
68912     try {
68913       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
68914     } catch (std::out_of_range& e) {
68915       {
68916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68917       };
68918     } catch (std::exception& e) {
68919       {
68920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68921       };
68922     } catch (Dali::DaliException e) {
68923       {
68924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68925       };
68926     } catch (...) {
68927       {
68928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68929       };
68930     }
68931   }
68932
68933   jresult = (void *)result;
68934   return jresult;
68935 }
68936
68937
68938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
68939   void * jresult ;
68940   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68941   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
68942
68943   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68944   {
68945     try {
68946       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
68947     } catch (std::out_of_range& e) {
68948       {
68949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68950       };
68951     } catch (std::exception& e) {
68952       {
68953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68954       };
68955     } catch (Dali::DaliException e) {
68956       {
68957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68958       };
68959     } catch (...) {
68960       {
68961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68962       };
68963     }
68964   }
68965
68966   jresult = (void *)result;
68967   return jresult;
68968 }
68969
68970
68971 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
68972   unsigned int jresult ;
68973   Dali::Toolkit::ControlOrientation::Type arg1 ;
68974   bool result;
68975
68976   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68977   {
68978     try {
68979       result = (bool)Dali::Toolkit::IsVertical(arg1);
68980     } catch (std::out_of_range& e) {
68981       {
68982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68983       };
68984     } catch (std::exception& e) {
68985       {
68986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68987       };
68988     } catch (Dali::DaliException e) {
68989       {
68990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68991       };
68992     } catch (...) {
68993       {
68994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68995       };
68996     }
68997   }
68998
68999   jresult = result;
69000   return jresult;
69001 }
69002
69003
69004 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
69005   unsigned int jresult ;
69006   Dali::Toolkit::ControlOrientation::Type arg1 ;
69007   bool result;
69008
69009   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69010   {
69011     try {
69012       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
69013     } catch (std::out_of_range& e) {
69014       {
69015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69016       };
69017     } catch (std::exception& e) {
69018       {
69019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69020       };
69021     } catch (Dali::DaliException e) {
69022       {
69023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69024       };
69025     } catch (...) {
69026       {
69027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69028       };
69029     }
69030   }
69031
69032   jresult = result;
69033   return jresult;
69034 }
69035
69036
69037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
69038   void * jresult ;
69039   unsigned int arg1 ;
69040   unsigned int arg2 ;
69041   Dali::Toolkit::ItemRange *result = 0 ;
69042
69043   arg1 = (unsigned int)jarg1;
69044   arg2 = (unsigned int)jarg2;
69045   {
69046     try {
69047       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
69048     } catch (std::out_of_range& e) {
69049       {
69050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69051       };
69052     } catch (std::exception& e) {
69053       {
69054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69055       };
69056     } catch (Dali::DaliException e) {
69057       {
69058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69059       };
69060     } catch (...) {
69061       {
69062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69063       };
69064     }
69065   }
69066
69067   jresult = (void *)result;
69068   return jresult;
69069 }
69070
69071
69072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
69073   void * jresult ;
69074   Dali::Toolkit::ItemRange *arg1 = 0 ;
69075   Dali::Toolkit::ItemRange *result = 0 ;
69076
69077   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69078   if (!arg1) {
69079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69080     return 0;
69081   }
69082   {
69083     try {
69084       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69085     } catch (std::out_of_range& e) {
69086       {
69087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69088       };
69089     } catch (std::exception& e) {
69090       {
69091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69092       };
69093     } catch (Dali::DaliException e) {
69094       {
69095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69096       };
69097     } catch (...) {
69098       {
69099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69100       };
69101     }
69102   }
69103
69104   jresult = (void *)result;
69105   return jresult;
69106 }
69107
69108
69109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69110   void * jresult ;
69111   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69112   Dali::Toolkit::ItemRange *arg2 = 0 ;
69113   Dali::Toolkit::ItemRange *result = 0 ;
69114
69115   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69116   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69117   if (!arg2) {
69118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69119     return 0;
69120   }
69121   {
69122     try {
69123       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69124     } catch (std::out_of_range& e) {
69125       {
69126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69127       };
69128     } catch (std::exception& e) {
69129       {
69130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69131       };
69132     } catch (Dali::DaliException e) {
69133       {
69134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69135       };
69136     } catch (...) {
69137       {
69138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69139       };
69140     }
69141   }
69142
69143   jresult = (void *)result;
69144   return jresult;
69145 }
69146
69147
69148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69149   unsigned int jresult ;
69150   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69151   unsigned int arg2 ;
69152   bool result;
69153
69154   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69155   arg2 = (unsigned int)jarg2;
69156   {
69157     try {
69158       result = (bool)(arg1)->Within(arg2);
69159     } catch (std::out_of_range& e) {
69160       {
69161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69162       };
69163     } catch (std::exception& e) {
69164       {
69165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69166       };
69167     } catch (Dali::DaliException e) {
69168       {
69169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69170       };
69171     } catch (...) {
69172       {
69173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69174       };
69175     }
69176   }
69177
69178   jresult = result;
69179   return jresult;
69180 }
69181
69182
69183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69184   void * jresult ;
69185   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69186   Dali::Toolkit::ItemRange *arg2 = 0 ;
69187   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69188
69189   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69190   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69191   if (!arg2) {
69192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69193     return 0;
69194   }
69195   {
69196     try {
69197       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69198     } catch (std::out_of_range& e) {
69199       {
69200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69201       };
69202     } catch (std::exception& e) {
69203       {
69204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69205       };
69206     } catch (Dali::DaliException e) {
69207       {
69208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69209       };
69210     } catch (...) {
69211       {
69212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69213       };
69214     }
69215   }
69216
69217   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69218   return jresult;
69219 }
69220
69221
69222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_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)->begin = arg2;
69229 }
69230
69231
69232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_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)->begin);
69239   jresult = result;
69240   return jresult;
69241 }
69242
69243
69244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69245   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69246   unsigned int arg2 ;
69247
69248   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69249   arg2 = (unsigned int)jarg2;
69250   if (arg1) (arg1)->end = arg2;
69251 }
69252
69253
69254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69255   unsigned int jresult ;
69256   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69257   unsigned int result;
69258
69259   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69260   result = (unsigned int) ((arg1)->end);
69261   jresult = result;
69262   return jresult;
69263 }
69264
69265
69266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69267   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69268
69269   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69270   {
69271     try {
69272       delete arg1;
69273     } catch (std::out_of_range& e) {
69274       {
69275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69276       };
69277     } catch (std::exception& e) {
69278       {
69279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69280       };
69281     } catch (Dali::DaliException e) {
69282       {
69283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69284       };
69285     } catch (...) {
69286       {
69287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69288       };
69289     }
69290   }
69291
69292 }
69293
69294
69295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69296   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69297
69298   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69299   {
69300     try {
69301       delete arg1;
69302     } catch (std::out_of_range& e) {
69303       {
69304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69305       };
69306     } catch (std::exception& e) {
69307       {
69308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69309       };
69310     } catch (Dali::DaliException e) {
69311       {
69312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69313       };
69314     } catch (...) {
69315       {
69316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69317       };
69318     }
69319   }
69320
69321 }
69322
69323
69324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69325   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69326   Dali::Toolkit::ControlOrientation::Type arg2 ;
69327
69328   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69329   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69330   {
69331     try {
69332       (arg1)->SetOrientation(arg2);
69333     } catch (std::out_of_range& e) {
69334       {
69335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69336       };
69337     } catch (std::exception& e) {
69338       {
69339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69340       };
69341     } catch (Dali::DaliException e) {
69342       {
69343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69344       };
69345     } catch (...) {
69346       {
69347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69348       };
69349     }
69350   }
69351
69352 }
69353
69354
69355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69356   int jresult ;
69357   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69358   Dali::Toolkit::ControlOrientation::Type result;
69359
69360   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69361   {
69362     try {
69363       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69364     } catch (std::out_of_range& e) {
69365       {
69366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69367       };
69368     } catch (std::exception& e) {
69369       {
69370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69371       };
69372     } catch (Dali::DaliException e) {
69373       {
69374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69375       };
69376     } catch (...) {
69377       {
69378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69379       };
69380     }
69381   }
69382
69383   jresult = (int)result;
69384   return jresult;
69385 }
69386
69387
69388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69389   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69390   Dali::Property::Map *arg2 = 0 ;
69391
69392   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69393   arg2 = (Dali::Property::Map *)jarg2;
69394   if (!arg2) {
69395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69396     return ;
69397   }
69398   {
69399     try {
69400       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69401     } catch (std::out_of_range& e) {
69402       {
69403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69404       };
69405     } catch (std::exception& e) {
69406       {
69407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69408       };
69409     } catch (Dali::DaliException e) {
69410       {
69411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69412       };
69413     } catch (...) {
69414       {
69415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69416       };
69417     }
69418   }
69419
69420 }
69421
69422
69423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69424   void * jresult ;
69425   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69426   Dali::Property::Map result;
69427
69428   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69429   {
69430     try {
69431       result = (arg1)->GetLayoutProperties();
69432     } catch (std::out_of_range& e) {
69433       {
69434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69435       };
69436     } catch (std::exception& e) {
69437       {
69438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69439       };
69440     } catch (Dali::DaliException e) {
69441       {
69442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69443       };
69444     } catch (...) {
69445       {
69446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69447       };
69448     }
69449   }
69450
69451   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69452   return jresult;
69453 }
69454
69455
69456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69457   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69458   unsigned int arg2 ;
69459   Dali::Vector3 *arg3 = 0 ;
69460   Dali::Vector3 *arg4 = 0 ;
69461
69462   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69463   arg2 = (unsigned int)jarg2;
69464   arg3 = (Dali::Vector3 *)jarg3;
69465   if (!arg3) {
69466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69467     return ;
69468   }
69469   arg4 = (Dali::Vector3 *)jarg4;
69470   if (!arg4) {
69471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69472     return ;
69473   }
69474   {
69475     try {
69476       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69477     } catch (std::out_of_range& e) {
69478       {
69479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69480       };
69481     } catch (std::exception& e) {
69482       {
69483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69484       };
69485     } catch (Dali::DaliException e) {
69486       {
69487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69488       };
69489     } catch (...) {
69490       {
69491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69492       };
69493     }
69494   }
69495
69496 }
69497
69498
69499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69500   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69501   Dali::Vector3 *arg2 = 0 ;
69502
69503   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69504   arg2 = (Dali::Vector3 *)jarg2;
69505   if (!arg2) {
69506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69507     return ;
69508   }
69509   {
69510     try {
69511       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69512     } catch (std::out_of_range& e) {
69513       {
69514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69515       };
69516     } catch (std::exception& e) {
69517       {
69518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69519       };
69520     } catch (Dali::DaliException e) {
69521       {
69522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69523       };
69524     } catch (...) {
69525       {
69526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69527       };
69528     }
69529   }
69530
69531 }
69532
69533
69534 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69535   float jresult ;
69536   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69537   unsigned int arg2 ;
69538   Dali::Vector3 arg3 ;
69539   Dali::Vector3 *argp3 ;
69540   float result;
69541
69542   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69543   arg2 = (unsigned int)jarg2;
69544   argp3 = (Dali::Vector3 *)jarg3;
69545   if (!argp3) {
69546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69547     return 0;
69548   }
69549   arg3 = *argp3;
69550   {
69551     try {
69552       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69553     } catch (std::out_of_range& e) {
69554       {
69555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69556       };
69557     } catch (std::exception& e) {
69558       {
69559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69560       };
69561     } catch (Dali::DaliException e) {
69562       {
69563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69564       };
69565     } catch (...) {
69566       {
69567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69568       };
69569     }
69570   }
69571
69572   jresult = result;
69573   return jresult;
69574 }
69575
69576
69577 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69578   float jresult ;
69579   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69580   float arg2 ;
69581   float result;
69582
69583   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69584   arg2 = (float)jarg2;
69585   {
69586     try {
69587       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69588     } catch (std::out_of_range& e) {
69589       {
69590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69591       };
69592     } catch (std::exception& e) {
69593       {
69594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69595       };
69596     } catch (Dali::DaliException e) {
69597       {
69598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69599       };
69600     } catch (...) {
69601       {
69602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69603       };
69604     }
69605   }
69606
69607   jresult = result;
69608   return jresult;
69609 }
69610
69611
69612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
69613   float jresult ;
69614   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69615   unsigned int arg2 ;
69616   float result;
69617
69618   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69619   arg2 = (unsigned int)jarg2;
69620   {
69621     try {
69622       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
69623     } catch (std::out_of_range& e) {
69624       {
69625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69626       };
69627     } catch (std::exception& e) {
69628       {
69629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69630       };
69631     } catch (Dali::DaliException e) {
69632       {
69633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69634       };
69635     } catch (...) {
69636       {
69637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69638       };
69639     }
69640   }
69641
69642   jresult = result;
69643   return jresult;
69644 }
69645
69646
69647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
69648   void * jresult ;
69649   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69650   float arg2 ;
69651   Dali::Vector3 arg3 ;
69652   Dali::Vector3 *argp3 ;
69653   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69654
69655   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69656   arg2 = (float)jarg2;
69657   argp3 = (Dali::Vector3 *)jarg3;
69658   if (!argp3) {
69659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69660     return 0;
69661   }
69662   arg3 = *argp3;
69663   {
69664     try {
69665       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69666     } catch (std::out_of_range& e) {
69667       {
69668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69669       };
69670     } catch (std::exception& e) {
69671       {
69672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69673       };
69674     } catch (Dali::DaliException e) {
69675       {
69676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69677       };
69678     } catch (...) {
69679       {
69680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69681       };
69682     }
69683   }
69684
69685   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69686   return jresult;
69687 }
69688
69689
69690 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69691   float jresult ;
69692   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69693   int arg2 ;
69694   float arg3 ;
69695   Dali::Vector3 *arg4 = 0 ;
69696   float result;
69697
69698   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69699   arg2 = (int)jarg2;
69700   arg3 = (float)jarg3;
69701   arg4 = (Dali::Vector3 *)jarg4;
69702   if (!arg4) {
69703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69704     return 0;
69705   }
69706   {
69707     try {
69708       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69709     } catch (std::out_of_range& e) {
69710       {
69711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69712       };
69713     } catch (std::exception& e) {
69714       {
69715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69716       };
69717     } catch (Dali::DaliException e) {
69718       {
69719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69720       };
69721     } catch (...) {
69722       {
69723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69724       };
69725     }
69726   }
69727
69728   jresult = result;
69729   return jresult;
69730 }
69731
69732
69733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
69734   unsigned int jresult ;
69735   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69736   Dali::Vector3 arg2 ;
69737   Dali::Vector3 *argp2 ;
69738   unsigned int result;
69739
69740   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69741   argp2 = (Dali::Vector3 *)jarg2;
69742   if (!argp2) {
69743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69744     return 0;
69745   }
69746   arg2 = *argp2;
69747   {
69748     try {
69749       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
69750     } catch (std::out_of_range& e) {
69751       {
69752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69753       };
69754     } catch (std::exception& e) {
69755       {
69756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69757       };
69758     } catch (Dali::DaliException e) {
69759       {
69760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69761       };
69762     } catch (...) {
69763       {
69764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69765       };
69766     }
69767   }
69768
69769   jresult = result;
69770   return jresult;
69771 }
69772
69773
69774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69775   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69776   unsigned int arg2 ;
69777   Dali::Vector3 *arg3 = 0 ;
69778   Dali::Vector3 *arg4 = 0 ;
69779
69780   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69781   arg2 = (unsigned int)jarg2;
69782   arg3 = (Dali::Vector3 *)jarg3;
69783   if (!arg3) {
69784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69785     return ;
69786   }
69787   arg4 = (Dali::Vector3 *)jarg4;
69788   if (!arg4) {
69789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69790     return ;
69791   }
69792   {
69793     try {
69794       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69795     } catch (std::out_of_range& e) {
69796       {
69797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69798       };
69799     } catch (std::exception& e) {
69800       {
69801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69802       };
69803     } catch (Dali::DaliException e) {
69804       {
69805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69806       };
69807     } catch (...) {
69808       {
69809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69810       };
69811     }
69812   }
69813
69814 }
69815
69816
69817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
69818   void * jresult ;
69819   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69820   Dali::Degree result;
69821
69822   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69823   {
69824     try {
69825       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69826     } catch (std::out_of_range& e) {
69827       {
69828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69829       };
69830     } catch (std::exception& e) {
69831       {
69832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69833       };
69834     } catch (Dali::DaliException e) {
69835       {
69836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69837       };
69838     } catch (...) {
69839       {
69840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69841       };
69842     }
69843   }
69844
69845   jresult = new Dali::Degree((const Dali::Degree &)result);
69846   return jresult;
69847 }
69848
69849
69850 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
69851   float jresult ;
69852   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69853   float result;
69854
69855   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69856   {
69857     try {
69858       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
69859     } catch (std::out_of_range& e) {
69860       {
69861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69862       };
69863     } catch (std::exception& e) {
69864       {
69865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69866       };
69867     } catch (Dali::DaliException e) {
69868       {
69869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69870       };
69871     } catch (...) {
69872       {
69873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69874       };
69875     }
69876   }
69877
69878   jresult = result;
69879   return jresult;
69880 }
69881
69882
69883 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
69884   float jresult ;
69885   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69886   float result;
69887
69888   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69889   {
69890     try {
69891       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
69892     } catch (std::out_of_range& e) {
69893       {
69894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69895       };
69896     } catch (std::exception& e) {
69897       {
69898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69899       };
69900     } catch (Dali::DaliException e) {
69901       {
69902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69903       };
69904     } catch (...) {
69905       {
69906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69907       };
69908     }
69909   }
69910
69911   jresult = result;
69912   return jresult;
69913 }
69914
69915
69916 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
69917   float jresult ;
69918   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69919   float result;
69920
69921   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69922   {
69923     try {
69924       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
69925     } catch (std::out_of_range& e) {
69926       {
69927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69928       };
69929     } catch (std::exception& e) {
69930       {
69931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69932       };
69933     } catch (Dali::DaliException e) {
69934       {
69935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69936       };
69937     } catch (...) {
69938       {
69939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69940       };
69941     }
69942   }
69943
69944   jresult = result;
69945   return jresult;
69946 }
69947
69948
69949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
69950   int jresult ;
69951   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69952   int arg2 ;
69953   int arg3 ;
69954   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
69955   bool arg5 ;
69956   int result;
69957
69958   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69959   arg2 = (int)jarg2;
69960   arg3 = (int)jarg3;
69961   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
69962   arg5 = jarg5 ? true : false;
69963   {
69964     try {
69965       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
69966     } catch (std::out_of_range& e) {
69967       {
69968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69969       };
69970     } catch (std::exception& e) {
69971       {
69972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69973       };
69974     } catch (Dali::DaliException e) {
69975       {
69976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69977       };
69978     } catch (...) {
69979       {
69980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69981       };
69982     }
69983   }
69984
69985   jresult = result;
69986   return jresult;
69987 }
69988
69989
69990 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
69991   float jresult ;
69992   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69993   float result;
69994
69995   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69996   {
69997     try {
69998       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
69999     } catch (std::out_of_range& e) {
70000       {
70001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70002       };
70003     } catch (std::exception& e) {
70004       {
70005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70006       };
70007     } catch (Dali::DaliException e) {
70008       {
70009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70010       };
70011     } catch (...) {
70012       {
70013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70014       };
70015     }
70016   }
70017
70018   jresult = result;
70019   return jresult;
70020 }
70021
70022
70023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
70024   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70025   Dali::Actor *arg2 = 0 ;
70026   int arg3 ;
70027   Dali::Vector3 *arg4 = 0 ;
70028   Dali::Actor *arg5 = 0 ;
70029
70030   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70031   arg2 = (Dali::Actor *)jarg2;
70032   if (!arg2) {
70033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70034     return ;
70035   }
70036   arg3 = (int)jarg3;
70037   arg4 = (Dali::Vector3 *)jarg4;
70038   if (!arg4) {
70039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70040     return ;
70041   }
70042   arg5 = (Dali::Actor *)jarg5;
70043   if (!arg5) {
70044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
70045     return ;
70046   }
70047   {
70048     try {
70049       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
70050     } catch (std::out_of_range& e) {
70051       {
70052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70053       };
70054     } catch (std::exception& e) {
70055       {
70056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70057       };
70058     } catch (Dali::DaliException e) {
70059       {
70060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70061       };
70062     } catch (...) {
70063       {
70064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70065       };
70066     }
70067   }
70068
70069 }
70070
70071
70072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70073   void * jresult ;
70074   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70075   int arg2 ;
70076   float arg3 ;
70077   Dali::Vector3 *arg4 = 0 ;
70078   Dali::Vector3 result;
70079
70080   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70081   arg2 = (int)jarg2;
70082   arg3 = (float)jarg3;
70083   arg4 = (Dali::Vector3 *)jarg4;
70084   if (!arg4) {
70085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70086     return 0;
70087   }
70088   {
70089     try {
70090       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70091     } catch (std::out_of_range& e) {
70092       {
70093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70094       };
70095     } catch (std::exception& e) {
70096       {
70097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70098       };
70099     } catch (Dali::DaliException e) {
70100       {
70101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70102       };
70103     } catch (...) {
70104       {
70105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70106       };
70107     }
70108   }
70109
70110   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70111   return jresult;
70112 }
70113
70114
70115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70116   void * jresult ;
70117   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70118   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70119
70120   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70121   {
70122     try {
70123       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70124     } catch (std::out_of_range& e) {
70125       {
70126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70127       };
70128     } catch (std::exception& e) {
70129       {
70130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70131       };
70132     } catch (Dali::DaliException e) {
70133       {
70134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70135       };
70136     } catch (...) {
70137       {
70138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70139       };
70140     }
70141   }
70142
70143   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70144   return jresult;
70145 }
70146
70147
70148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70149   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70150
70151   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70152   {
70153     try {
70154       delete arg1;
70155     } catch (std::out_of_range& e) {
70156       {
70157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70158       };
70159     } catch (std::exception& e) {
70160       {
70161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70162       };
70163     } catch (Dali::DaliException e) {
70164       {
70165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70166       };
70167     } catch (...) {
70168       {
70169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70170       };
70171     }
70172   }
70173
70174 }
70175
70176
70177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70178   unsigned int jresult ;
70179   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70180   unsigned int result;
70181
70182   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70183   {
70184     try {
70185       result = (unsigned int)(arg1)->GetNumberOfItems();
70186     } catch (std::out_of_range& e) {
70187       {
70188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70189       };
70190     } catch (std::exception& e) {
70191       {
70192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70193       };
70194     } catch (Dali::DaliException e) {
70195       {
70196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70197       };
70198     } catch (...) {
70199       {
70200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70201       };
70202     }
70203   }
70204
70205   jresult = result;
70206   return jresult;
70207 }
70208
70209
70210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70211   void * jresult ;
70212   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70213   unsigned int arg2 ;
70214   Dali::Actor result;
70215
70216   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70217   arg2 = (unsigned int)jarg2;
70218   {
70219     try {
70220       result = (arg1)->NewItem(arg2);
70221     } catch (std::out_of_range& e) {
70222       {
70223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70224       };
70225     } catch (std::exception& e) {
70226       {
70227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70228       };
70229     } catch (Dali::DaliException e) {
70230       {
70231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70232       };
70233     } catch (...) {
70234       {
70235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70236       };
70237     }
70238   }
70239
70240   jresult = new Dali::Actor((const Dali::Actor &)result);
70241   return jresult;
70242 }
70243
70244
70245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70246   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70247   unsigned int arg2 ;
70248   Dali::Actor arg3 ;
70249   Dali::Actor *argp3 ;
70250
70251   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70252   arg2 = (unsigned int)jarg2;
70253   argp3 = (Dali::Actor *)jarg3;
70254   if (!argp3) {
70255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70256     return ;
70257   }
70258   arg3 = *argp3;
70259   {
70260     try {
70261       (arg1)->ItemReleased(arg2,arg3);
70262     } catch (std::out_of_range& e) {
70263       {
70264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70265       };
70266     } catch (std::exception& e) {
70267       {
70268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70269       };
70270     } catch (Dali::DaliException e) {
70271       {
70272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70273       };
70274     } catch (...) {
70275       {
70276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70277       };
70278     }
70279   }
70280
70281 }
70282
70283
70284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70285   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70286   unsigned int arg2 ;
70287   Dali::Actor arg3 ;
70288   Dali::Actor *argp3 ;
70289
70290   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70291   arg2 = (unsigned int)jarg2;
70292   argp3 = (Dali::Actor *)jarg3;
70293   if (!argp3) {
70294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70295     return ;
70296   }
70297   arg3 = *argp3;
70298   {
70299     try {
70300       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70301     } catch (std::out_of_range& e) {
70302       {
70303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70304       };
70305     } catch (std::exception& e) {
70306       {
70307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70308       };
70309     } catch (Dali::DaliException e) {
70310       {
70311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70312       };
70313     } catch (...) {
70314       {
70315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70316       };
70317     }
70318   }
70319
70320 }
70321
70322
70323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70324   void * jresult ;
70325   Dali::Toolkit::ItemFactory *result = 0 ;
70326
70327   {
70328     try {
70329       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70330     } catch (std::out_of_range& e) {
70331       {
70332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70333       };
70334     } catch (std::exception& e) {
70335       {
70336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70337       };
70338     } catch (Dali::DaliException e) {
70339       {
70340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70341       };
70342     } catch (...) {
70343       {
70344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70345       };
70346     }
70347   }
70348
70349   jresult = (void *)result;
70350   return jresult;
70351 }
70352
70353
70354 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) {
70355   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70356   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70357   if (director) {
70358     director->swig_connect_director(callback0, callback1, callback2);
70359   }
70360 }
70361
70362
70363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70364   int jresult ;
70365   int result;
70366
70367   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70368   jresult = (int)result;
70369   return jresult;
70370 }
70371
70372
70373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70374   int jresult ;
70375   int result;
70376
70377   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70378   jresult = (int)result;
70379   return jresult;
70380 }
70381
70382
70383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70384   int jresult ;
70385   int result;
70386
70387   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70388   jresult = (int)result;
70389   return jresult;
70390 }
70391
70392
70393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70394   int jresult ;
70395   int result;
70396
70397   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70398   jresult = (int)result;
70399   return jresult;
70400 }
70401
70402
70403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70404   int jresult ;
70405   int result;
70406
70407   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70408   jresult = (int)result;
70409   return jresult;
70410 }
70411
70412
70413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70414   int jresult ;
70415   int result;
70416
70417   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70418   jresult = (int)result;
70419   return jresult;
70420 }
70421
70422
70423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70424   int jresult ;
70425   int result;
70426
70427   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70428   jresult = (int)result;
70429   return jresult;
70430 }
70431
70432
70433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70434   int jresult ;
70435   int result;
70436
70437   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70438   jresult = (int)result;
70439   return jresult;
70440 }
70441
70442
70443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70444   int jresult ;
70445   int result;
70446
70447   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70448   jresult = (int)result;
70449   return jresult;
70450 }
70451
70452
70453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70454   int jresult ;
70455   int result;
70456
70457   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70458   jresult = (int)result;
70459   return jresult;
70460 }
70461
70462
70463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70464   int jresult ;
70465   int result;
70466
70467   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70468   jresult = (int)result;
70469   return jresult;
70470 }
70471
70472
70473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70474   void * jresult ;
70475   Dali::Toolkit::ItemView::Property *result = 0 ;
70476
70477   {
70478     try {
70479       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70480     } catch (std::out_of_range& e) {
70481       {
70482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70483       };
70484     } catch (std::exception& e) {
70485       {
70486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70487       };
70488     } catch (Dali::DaliException e) {
70489       {
70490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70491       };
70492     } catch (...) {
70493       {
70494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70495       };
70496     }
70497   }
70498
70499   jresult = (void *)result;
70500   return jresult;
70501 }
70502
70503
70504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70505   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70506
70507   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70508   {
70509     try {
70510       delete arg1;
70511     } catch (std::out_of_range& e) {
70512       {
70513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70514       };
70515     } catch (std::exception& e) {
70516       {
70517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70518       };
70519     } catch (Dali::DaliException e) {
70520       {
70521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70522       };
70523     } catch (...) {
70524       {
70525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70526       };
70527     }
70528   }
70529
70530 }
70531
70532
70533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70534   void * jresult ;
70535   Dali::Toolkit::ItemView *result = 0 ;
70536
70537   {
70538     try {
70539       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70540     } catch (std::out_of_range& e) {
70541       {
70542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70543       };
70544     } catch (std::exception& e) {
70545       {
70546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70547       };
70548     } catch (Dali::DaliException e) {
70549       {
70550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70551       };
70552     } catch (...) {
70553       {
70554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70555       };
70556     }
70557   }
70558
70559   jresult = (void *)result;
70560   return jresult;
70561 }
70562
70563
70564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70565   void * jresult ;
70566   Dali::Toolkit::ItemView *arg1 = 0 ;
70567   Dali::Toolkit::ItemView *result = 0 ;
70568
70569   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70570   if (!arg1) {
70571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70572     return 0;
70573   }
70574   {
70575     try {
70576       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70577     } catch (std::out_of_range& e) {
70578       {
70579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70580       };
70581     } catch (std::exception& e) {
70582       {
70583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70584       };
70585     } catch (Dali::DaliException e) {
70586       {
70587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70588       };
70589     } catch (...) {
70590       {
70591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70592       };
70593     }
70594   }
70595
70596   jresult = (void *)result;
70597   return jresult;
70598 }
70599
70600
70601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70602   void * jresult ;
70603   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70604   Dali::Toolkit::ItemView *arg2 = 0 ;
70605   Dali::Toolkit::ItemView *result = 0 ;
70606
70607   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70608   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70609   if (!arg2) {
70610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70611     return 0;
70612   }
70613   {
70614     try {
70615       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70616     } catch (std::out_of_range& e) {
70617       {
70618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70619       };
70620     } catch (std::exception& e) {
70621       {
70622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70623       };
70624     } catch (Dali::DaliException e) {
70625       {
70626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70627       };
70628     } catch (...) {
70629       {
70630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70631       };
70632     }
70633   }
70634
70635   jresult = (void *)result;
70636   return jresult;
70637 }
70638
70639
70640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70641   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70642
70643   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70644   {
70645     try {
70646       delete arg1;
70647     } catch (std::out_of_range& e) {
70648       {
70649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70650       };
70651     } catch (std::exception& e) {
70652       {
70653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70654       };
70655     } catch (Dali::DaliException e) {
70656       {
70657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70658       };
70659     } catch (...) {
70660       {
70661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70662       };
70663     }
70664   }
70665
70666 }
70667
70668
70669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70670   void * jresult ;
70671   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70672   Dali::Toolkit::ItemView result;
70673
70674   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70675   if (!arg1) {
70676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70677     return 0;
70678   }
70679   {
70680     try {
70681       result = Dali::Toolkit::ItemView::New(*arg1);
70682     } catch (std::out_of_range& e) {
70683       {
70684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70685       };
70686     } catch (std::exception& e) {
70687       {
70688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70689       };
70690     } catch (Dali::DaliException e) {
70691       {
70692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70693       };
70694     } catch (...) {
70695       {
70696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70697       };
70698     }
70699   }
70700
70701   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70702   return jresult;
70703 }
70704
70705
70706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70707   void * jresult ;
70708   Dali::BaseHandle arg1 ;
70709   Dali::BaseHandle *argp1 ;
70710   Dali::Toolkit::ItemView result;
70711
70712   argp1 = (Dali::BaseHandle *)jarg1;
70713   if (!argp1) {
70714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70715     return 0;
70716   }
70717   arg1 = *argp1;
70718   {
70719     try {
70720       result = Dali::Toolkit::ItemView::DownCast(arg1);
70721     } catch (std::out_of_range& e) {
70722       {
70723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70724       };
70725     } catch (std::exception& e) {
70726       {
70727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70728       };
70729     } catch (Dali::DaliException e) {
70730       {
70731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70732       };
70733     } catch (...) {
70734       {
70735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70736       };
70737     }
70738   }
70739
70740   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70741   return jresult;
70742 }
70743
70744
70745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
70746   unsigned int jresult ;
70747   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70748   unsigned int result;
70749
70750   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70751   {
70752     try {
70753       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
70754     } catch (std::out_of_range& e) {
70755       {
70756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70757       };
70758     } catch (std::exception& e) {
70759       {
70760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70761       };
70762     } catch (Dali::DaliException e) {
70763       {
70764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70765       };
70766     } catch (...) {
70767       {
70768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70769       };
70770     }
70771   }
70772
70773   jresult = result;
70774   return jresult;
70775 }
70776
70777
70778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
70779   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70780   Dali::Toolkit::ItemLayout *arg2 = 0 ;
70781
70782   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70783   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
70784   if (!arg2) {
70785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
70786     return ;
70787   }
70788   {
70789     try {
70790       (arg1)->AddLayout(*arg2);
70791     } catch (std::out_of_range& e) {
70792       {
70793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70794       };
70795     } catch (std::exception& e) {
70796       {
70797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70798       };
70799     } catch (Dali::DaliException e) {
70800       {
70801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70802       };
70803     } catch (...) {
70804       {
70805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70806       };
70807     }
70808   }
70809
70810 }
70811
70812
70813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
70814   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70815   unsigned int arg2 ;
70816
70817   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70818   arg2 = (unsigned int)jarg2;
70819   {
70820     try {
70821       (arg1)->RemoveLayout(arg2);
70822     } catch (std::out_of_range& e) {
70823       {
70824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70825       };
70826     } catch (std::exception& e) {
70827       {
70828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70829       };
70830     } catch (Dali::DaliException e) {
70831       {
70832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70833       };
70834     } catch (...) {
70835       {
70836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70837       };
70838     }
70839   }
70840
70841 }
70842
70843
70844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70845   void * jresult ;
70846   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70847   unsigned int arg2 ;
70848   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70849
70850   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70851   arg2 = (unsigned int)jarg2;
70852   {
70853     try {
70854       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
70855     } catch (std::out_of_range& e) {
70856       {
70857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70858       };
70859     } catch (std::exception& e) {
70860       {
70861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70862       };
70863     } catch (Dali::DaliException e) {
70864       {
70865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70866       };
70867     } catch (...) {
70868       {
70869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70870       };
70871     }
70872   }
70873
70874   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70875   return jresult;
70876 }
70877
70878
70879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
70880   void * jresult ;
70881   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70882   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70883
70884   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70885   {
70886     try {
70887       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
70888     } catch (std::out_of_range& e) {
70889       {
70890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70891       };
70892     } catch (std::exception& e) {
70893       {
70894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70895       };
70896     } catch (Dali::DaliException e) {
70897       {
70898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70899       };
70900     } catch (...) {
70901       {
70902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70903       };
70904     }
70905   }
70906
70907   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70908   return jresult;
70909 }
70910
70911
70912 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
70913   float jresult ;
70914   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70915   Dali::Toolkit::ItemId arg2 ;
70916   float result;
70917
70918   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70919   arg2 = (Dali::Toolkit::ItemId)jarg2;
70920   {
70921     try {
70922       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
70923     } catch (std::out_of_range& e) {
70924       {
70925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70926       };
70927     } catch (std::exception& e) {
70928       {
70929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70930       };
70931     } catch (Dali::DaliException e) {
70932       {
70933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70934       };
70935     } catch (...) {
70936       {
70937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70938       };
70939     }
70940   }
70941
70942   jresult = result;
70943   return jresult;
70944 }
70945
70946
70947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
70948   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70949   unsigned int arg2 ;
70950   Dali::Vector3 arg3 ;
70951   float arg4 ;
70952   Dali::Vector3 *argp3 ;
70953
70954   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70955   arg2 = (unsigned int)jarg2;
70956   argp3 = (Dali::Vector3 *)jarg3;
70957   if (!argp3) {
70958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70959     return ;
70960   }
70961   arg3 = *argp3;
70962   arg4 = (float)jarg4;
70963   {
70964     try {
70965       (arg1)->ActivateLayout(arg2,arg3,arg4);
70966     } catch (std::out_of_range& e) {
70967       {
70968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70969       };
70970     } catch (std::exception& e) {
70971       {
70972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70973       };
70974     } catch (Dali::DaliException e) {
70975       {
70976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70977       };
70978     } catch (...) {
70979       {
70980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70981       };
70982     }
70983   }
70984
70985 }
70986
70987
70988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
70989   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70990
70991   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70992   {
70993     try {
70994       (arg1)->DeactivateCurrentLayout();
70995     } catch (std::out_of_range& e) {
70996       {
70997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70998       };
70999     } catch (std::exception& e) {
71000       {
71001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71002       };
71003     } catch (Dali::DaliException e) {
71004       {
71005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71006       };
71007     } catch (...) {
71008       {
71009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71010       };
71011     }
71012   }
71013
71014 }
71015
71016
71017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
71018   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71019   float arg2 ;
71020
71021   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71022   arg2 = (float)jarg2;
71023   {
71024     try {
71025       (arg1)->SetMinimumSwipeSpeed(arg2);
71026     } catch (std::out_of_range& e) {
71027       {
71028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71029       };
71030     } catch (std::exception& e) {
71031       {
71032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71033       };
71034     } catch (Dali::DaliException e) {
71035       {
71036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71037       };
71038     } catch (...) {
71039       {
71040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71041       };
71042     }
71043   }
71044
71045 }
71046
71047
71048 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
71049   float jresult ;
71050   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71051   float result;
71052
71053   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71054   {
71055     try {
71056       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
71057     } catch (std::out_of_range& e) {
71058       {
71059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71060       };
71061     } catch (std::exception& e) {
71062       {
71063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71064       };
71065     } catch (Dali::DaliException e) {
71066       {
71067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71068       };
71069     } catch (...) {
71070       {
71071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71072       };
71073     }
71074   }
71075
71076   jresult = result;
71077   return jresult;
71078 }
71079
71080
71081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
71082   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71083   float arg2 ;
71084
71085   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71086   arg2 = (float)jarg2;
71087   {
71088     try {
71089       (arg1)->SetMinimumSwipeDistance(arg2);
71090     } catch (std::out_of_range& e) {
71091       {
71092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71093       };
71094     } catch (std::exception& e) {
71095       {
71096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71097       };
71098     } catch (Dali::DaliException e) {
71099       {
71100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71101       };
71102     } catch (...) {
71103       {
71104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71105       };
71106     }
71107   }
71108
71109 }
71110
71111
71112 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71113   float jresult ;
71114   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71115   float result;
71116
71117   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71118   {
71119     try {
71120       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71121     } catch (std::out_of_range& e) {
71122       {
71123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71124       };
71125     } catch (std::exception& e) {
71126       {
71127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71128       };
71129     } catch (Dali::DaliException e) {
71130       {
71131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71132       };
71133     } catch (...) {
71134       {
71135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71136       };
71137     }
71138   }
71139
71140   jresult = result;
71141   return jresult;
71142 }
71143
71144
71145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71146   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71147   float arg2 ;
71148
71149   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71150   arg2 = (float)jarg2;
71151   {
71152     try {
71153       (arg1)->SetWheelScrollDistanceStep(arg2);
71154     } catch (std::out_of_range& e) {
71155       {
71156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71157       };
71158     } catch (std::exception& e) {
71159       {
71160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71161       };
71162     } catch (Dali::DaliException e) {
71163       {
71164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71165       };
71166     } catch (...) {
71167       {
71168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71169       };
71170     }
71171   }
71172
71173 }
71174
71175
71176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71177   float jresult ;
71178   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71179   float result;
71180
71181   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71182   {
71183     try {
71184       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71185     } catch (std::out_of_range& e) {
71186       {
71187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71188       };
71189     } catch (std::exception& e) {
71190       {
71191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71192       };
71193     } catch (Dali::DaliException e) {
71194       {
71195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71196       };
71197     } catch (...) {
71198       {
71199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71200       };
71201     }
71202   }
71203
71204   jresult = result;
71205   return jresult;
71206 }
71207
71208
71209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71210   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71211   bool arg2 ;
71212
71213   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71214   arg2 = jarg2 ? true : false;
71215   {
71216     try {
71217       (arg1)->SetAnchoring(arg2);
71218     } catch (std::out_of_range& e) {
71219       {
71220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71221       };
71222     } catch (std::exception& e) {
71223       {
71224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71225       };
71226     } catch (Dali::DaliException e) {
71227       {
71228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71229       };
71230     } catch (...) {
71231       {
71232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71233       };
71234     }
71235   }
71236
71237 }
71238
71239 //// ========================= end of part 3 =============================
71240
71241 //// ========================== start part 4 ===============================
71242
71243
71244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71245   unsigned int jresult ;
71246   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71247   bool result;
71248
71249   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71250   {
71251     try {
71252       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71253     } catch (std::out_of_range& e) {
71254       {
71255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71256       };
71257     } catch (std::exception& e) {
71258       {
71259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71260       };
71261     } catch (Dali::DaliException e) {
71262       {
71263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71264       };
71265     } catch (...) {
71266       {
71267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71268       };
71269     }
71270   }
71271
71272   jresult = result;
71273   return jresult;
71274 }
71275
71276
71277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71278   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71279   float arg2 ;
71280
71281   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71282   arg2 = (float)jarg2;
71283   {
71284     try {
71285       (arg1)->SetAnchoringDuration(arg2);
71286     } catch (std::out_of_range& e) {
71287       {
71288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71289       };
71290     } catch (std::exception& e) {
71291       {
71292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71293       };
71294     } catch (Dali::DaliException e) {
71295       {
71296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71297       };
71298     } catch (...) {
71299       {
71300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71301       };
71302     }
71303   }
71304
71305 }
71306
71307
71308 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71309   float jresult ;
71310   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71311   float result;
71312
71313   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71314   {
71315     try {
71316       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71317     } catch (std::out_of_range& e) {
71318       {
71319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71320       };
71321     } catch (std::exception& e) {
71322       {
71323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71324       };
71325     } catch (Dali::DaliException e) {
71326       {
71327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71328       };
71329     } catch (...) {
71330       {
71331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71332       };
71333     }
71334   }
71335
71336   jresult = result;
71337   return jresult;
71338 }
71339
71340
71341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71342   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71343   Dali::Toolkit::ItemId arg2 ;
71344   float arg3 ;
71345
71346   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71347   arg2 = (Dali::Toolkit::ItemId)jarg2;
71348   arg3 = (float)jarg3;
71349   {
71350     try {
71351       (arg1)->ScrollToItem(arg2,arg3);
71352     } catch (std::out_of_range& e) {
71353       {
71354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71355       };
71356     } catch (std::exception& e) {
71357       {
71358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71359       };
71360     } catch (Dali::DaliException e) {
71361       {
71362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71363       };
71364     } catch (...) {
71365       {
71366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71367       };
71368     }
71369   }
71370
71371 }
71372
71373
71374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71375   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71376   float arg2 ;
71377
71378   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71379   arg2 = (float)jarg2;
71380   {
71381     try {
71382       (arg1)->SetRefreshInterval(arg2);
71383     } catch (std::out_of_range& e) {
71384       {
71385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71386       };
71387     } catch (std::exception& e) {
71388       {
71389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71390       };
71391     } catch (Dali::DaliException e) {
71392       {
71393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71394       };
71395     } catch (...) {
71396       {
71397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71398       };
71399     }
71400   }
71401
71402 }
71403
71404
71405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71406   float jresult ;
71407   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71408   float result;
71409
71410   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71411   {
71412     try {
71413       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71414     } catch (std::out_of_range& e) {
71415       {
71416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71417       };
71418     } catch (std::exception& e) {
71419       {
71420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71421       };
71422     } catch (Dali::DaliException e) {
71423       {
71424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71425       };
71426     } catch (...) {
71427       {
71428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71429       };
71430     }
71431   }
71432
71433   jresult = result;
71434   return jresult;
71435 }
71436
71437
71438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71439   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71440
71441   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71442   {
71443     try {
71444       (arg1)->Refresh();
71445     } catch (std::out_of_range& e) {
71446       {
71447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71448       };
71449     } catch (std::exception& e) {
71450       {
71451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71452       };
71453     } catch (Dali::DaliException e) {
71454       {
71455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71456       };
71457     } catch (...) {
71458       {
71459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71460       };
71461     }
71462   }
71463
71464 }
71465
71466
71467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71468   void * jresult ;
71469   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71470   Dali::Toolkit::ItemId arg2 ;
71471   Dali::Actor result;
71472
71473   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71474   arg2 = (Dali::Toolkit::ItemId)jarg2;
71475   {
71476     try {
71477       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71478     } catch (std::out_of_range& e) {
71479       {
71480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71481       };
71482     } catch (std::exception& e) {
71483       {
71484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71485       };
71486     } catch (Dali::DaliException e) {
71487       {
71488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71489       };
71490     } catch (...) {
71491       {
71492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71493       };
71494     }
71495   }
71496
71497   jresult = new Dali::Actor((const Dali::Actor &)result);
71498   return jresult;
71499 }
71500
71501
71502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71503   unsigned int jresult ;
71504   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71505   Dali::Actor arg2 ;
71506   Dali::Actor *argp2 ;
71507   Dali::Toolkit::ItemId result;
71508
71509   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71510   argp2 = (Dali::Actor *)jarg2;
71511   if (!argp2) {
71512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71513     return 0;
71514   }
71515   arg2 = *argp2;
71516   {
71517     try {
71518       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71519     } catch (std::out_of_range& e) {
71520       {
71521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71522       };
71523     } catch (std::exception& e) {
71524       {
71525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71526       };
71527     } catch (Dali::DaliException e) {
71528       {
71529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71530       };
71531     } catch (...) {
71532       {
71533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71534       };
71535     }
71536   }
71537
71538   jresult = result;
71539   return jresult;
71540 }
71541
71542
71543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71544   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71545   Dali::Toolkit::Item arg2 ;
71546   float arg3 ;
71547   Dali::Toolkit::Item *argp2 ;
71548
71549   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71550   argp2 = (Dali::Toolkit::Item *)jarg2;
71551   if (!argp2) {
71552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71553     return ;
71554   }
71555   arg2 = *argp2;
71556   arg3 = (float)jarg3;
71557   {
71558     try {
71559       (arg1)->InsertItem(arg2,arg3);
71560     } catch (std::out_of_range& e) {
71561       {
71562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71563       };
71564     } catch (std::exception& e) {
71565       {
71566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71567       };
71568     } catch (Dali::DaliException e) {
71569       {
71570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71571       };
71572     } catch (...) {
71573       {
71574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71575       };
71576     }
71577   }
71578
71579 }
71580
71581
71582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71583   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71584   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71585   float arg3 ;
71586
71587   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71588   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71589   if (!arg2) {
71590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71591     return ;
71592   }
71593   arg3 = (float)jarg3;
71594   {
71595     try {
71596       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71597     } catch (std::out_of_range& e) {
71598       {
71599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71600       };
71601     } catch (std::exception& e) {
71602       {
71603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71604       };
71605     } catch (Dali::DaliException e) {
71606       {
71607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71608       };
71609     } catch (...) {
71610       {
71611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71612       };
71613     }
71614   }
71615
71616 }
71617
71618
71619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71620   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71621   Dali::Toolkit::ItemId arg2 ;
71622   float arg3 ;
71623
71624   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71625   arg2 = (Dali::Toolkit::ItemId)jarg2;
71626   arg3 = (float)jarg3;
71627   {
71628     try {
71629       (arg1)->RemoveItem(arg2,arg3);
71630     } catch (std::out_of_range& e) {
71631       {
71632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71633       };
71634     } catch (std::exception& e) {
71635       {
71636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71637       };
71638     } catch (Dali::DaliException e) {
71639       {
71640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71641       };
71642     } catch (...) {
71643       {
71644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71645       };
71646     }
71647   }
71648
71649 }
71650
71651
71652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71653   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71654   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71655   float arg3 ;
71656
71657   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71658   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71659   if (!arg2) {
71660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71661     return ;
71662   }
71663   arg3 = (float)jarg3;
71664   {
71665     try {
71666       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71667     } catch (std::out_of_range& e) {
71668       {
71669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71670       };
71671     } catch (std::exception& e) {
71672       {
71673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71674       };
71675     } catch (Dali::DaliException e) {
71676       {
71677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71678       };
71679     } catch (...) {
71680       {
71681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71682       };
71683     }
71684   }
71685
71686 }
71687
71688
71689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71690   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71691   Dali::Toolkit::Item arg2 ;
71692   float arg3 ;
71693   Dali::Toolkit::Item *argp2 ;
71694
71695   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71696   argp2 = (Dali::Toolkit::Item *)jarg2;
71697   if (!argp2) {
71698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71699     return ;
71700   }
71701   arg2 = *argp2;
71702   arg3 = (float)jarg3;
71703   {
71704     try {
71705       (arg1)->ReplaceItem(arg2,arg3);
71706     } catch (std::out_of_range& e) {
71707       {
71708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71709       };
71710     } catch (std::exception& e) {
71711       {
71712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71713       };
71714     } catch (Dali::DaliException e) {
71715       {
71716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71717       };
71718     } catch (...) {
71719       {
71720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71721       };
71722     }
71723   }
71724
71725 }
71726
71727
71728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71729   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71730   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71731   float arg3 ;
71732
71733   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71734   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71735   if (!arg2) {
71736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71737     return ;
71738   }
71739   arg3 = (float)jarg3;
71740   {
71741     try {
71742       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71743     } catch (std::out_of_range& e) {
71744       {
71745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71746       };
71747     } catch (std::exception& e) {
71748       {
71749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71750       };
71751     } catch (Dali::DaliException e) {
71752       {
71753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71754       };
71755     } catch (...) {
71756       {
71757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71758       };
71759     }
71760   }
71761
71762 }
71763
71764
71765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71766   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71767   Dali::Vector3 *arg2 = 0 ;
71768
71769   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71770   arg2 = (Dali::Vector3 *)jarg2;
71771   if (!arg2) {
71772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71773     return ;
71774   }
71775   {
71776     try {
71777       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71778     } catch (std::out_of_range& e) {
71779       {
71780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71781       };
71782     } catch (std::exception& e) {
71783       {
71784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71785       };
71786     } catch (Dali::DaliException e) {
71787       {
71788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71789       };
71790     } catch (...) {
71791       {
71792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71793       };
71794     }
71795   }
71796
71797 }
71798
71799
71800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
71801   void * jresult ;
71802   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71803   Dali::Vector3 result;
71804
71805   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71806   {
71807     try {
71808       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71809     } catch (std::out_of_range& e) {
71810       {
71811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71812       };
71813     } catch (std::exception& e) {
71814       {
71815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71816       };
71817     } catch (Dali::DaliException e) {
71818       {
71819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71820       };
71821     } catch (...) {
71822       {
71823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71824       };
71825     }
71826   }
71827
71828   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71829   return jresult;
71830 }
71831
71832
71833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71834   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71835   Dali::Vector3 *arg2 = 0 ;
71836
71837   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71838   arg2 = (Dali::Vector3 *)jarg2;
71839   if (!arg2) {
71840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71841     return ;
71842   }
71843   {
71844     try {
71845       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71846     } catch (std::out_of_range& e) {
71847       {
71848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71849       };
71850     } catch (std::exception& e) {
71851       {
71852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71853       };
71854     } catch (Dali::DaliException e) {
71855       {
71856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71857       };
71858     } catch (...) {
71859       {
71860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71861       };
71862     }
71863   }
71864
71865 }
71866
71867
71868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
71869   void * jresult ;
71870   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71871   Dali::Vector3 result;
71872
71873   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71874   {
71875     try {
71876       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
71877     } catch (std::out_of_range& e) {
71878       {
71879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71880       };
71881     } catch (std::exception& e) {
71882       {
71883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71884       };
71885     } catch (Dali::DaliException e) {
71886       {
71887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71888       };
71889     } catch (...) {
71890       {
71891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71892       };
71893     }
71894   }
71895
71896   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71897   return jresult;
71898 }
71899
71900
71901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
71902   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71903   Dali::Toolkit::ItemRange *arg2 = 0 ;
71904
71905   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71906   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
71907   if (!arg2) {
71908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
71909     return ;
71910   }
71911   {
71912     try {
71913       (arg1)->GetItemsRange(*arg2);
71914     } catch (std::out_of_range& e) {
71915       {
71916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71917       };
71918     } catch (std::exception& e) {
71919       {
71920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71921       };
71922     } catch (Dali::DaliException e) {
71923       {
71924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71925       };
71926     } catch (...) {
71927       {
71928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71929       };
71930     }
71931   }
71932
71933 }
71934
71935
71936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
71937   void * jresult ;
71938   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71939   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
71940
71941   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71942   {
71943     try {
71944       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
71945     } catch (std::out_of_range& e) {
71946       {
71947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71948       };
71949     } catch (std::exception& e) {
71950       {
71951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71952       };
71953     } catch (Dali::DaliException e) {
71954       {
71955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71956       };
71957     } catch (...) {
71958       {
71959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71960       };
71961     }
71962   }
71963
71964   jresult = (void *)result;
71965   return jresult;
71966 }
71967
71968
71969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
71970   Dali::Vector3 *arg1 = 0 ;
71971   PropertyInputContainer *arg2 = 0 ;
71972
71973   arg1 = (Dali::Vector3 *)jarg1;
71974   if (!arg1) {
71975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71976     return ;
71977   }
71978   arg2 = (PropertyInputContainer *)jarg2;
71979   if (!arg2) {
71980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71981     return ;
71982   }
71983   {
71984     try {
71985       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71986     } catch (std::out_of_range& e) {
71987       {
71988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71989       };
71990     } catch (std::exception& e) {
71991       {
71992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71993       };
71994     } catch (Dali::DaliException e) {
71995       {
71996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71997       };
71998     } catch (...) {
71999       {
72000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72001       };
72002     }
72003   }
72004
72005 }
72006
72007
72008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
72009   Dali::Vector3 *arg1 = 0 ;
72010   PropertyInputContainer *arg2 = 0 ;
72011
72012   arg1 = (Dali::Vector3 *)jarg1;
72013   if (!arg1) {
72014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72015     return ;
72016   }
72017   arg2 = (PropertyInputContainer *)jarg2;
72018   if (!arg2) {
72019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72020     return ;
72021   }
72022   {
72023     try {
72024       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72025     } catch (std::out_of_range& e) {
72026       {
72027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72028       };
72029     } catch (std::exception& e) {
72030       {
72031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72032       };
72033     } catch (Dali::DaliException e) {
72034       {
72035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72036       };
72037     } catch (...) {
72038       {
72039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72040       };
72041     }
72042   }
72043
72044 }
72045
72046
72047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
72048   void * jresult ;
72049   Dali::Toolkit::ScrollViewEffect *result = 0 ;
72050
72051   {
72052     try {
72053       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
72054     } catch (std::out_of_range& e) {
72055       {
72056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72057       };
72058     } catch (std::exception& e) {
72059       {
72060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72061       };
72062     } catch (Dali::DaliException e) {
72063       {
72064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72065       };
72066     } catch (...) {
72067       {
72068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72069       };
72070     }
72071   }
72072
72073   jresult = (void *)result;
72074   return jresult;
72075 }
72076
72077
72078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
72079   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
72080
72081   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
72082   {
72083     try {
72084       delete arg1;
72085     } catch (std::out_of_range& e) {
72086       {
72087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72088       };
72089     } catch (std::exception& e) {
72090       {
72091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72092       };
72093     } catch (Dali::DaliException e) {
72094       {
72095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72096       };
72097     } catch (...) {
72098       {
72099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72100       };
72101     }
72102   }
72103
72104 }
72105
72106
72107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72108   void * jresult ;
72109   Dali::Path arg1 ;
72110   Dali::Vector3 *arg2 = 0 ;
72111   Dali::Property::Index arg3 ;
72112   Dali::Vector3 *arg4 = 0 ;
72113   unsigned int arg5 ;
72114   Dali::Path *argp1 ;
72115   Dali::Toolkit::ScrollViewPagePathEffect result;
72116
72117   argp1 = (Dali::Path *)jarg1;
72118   if (!argp1) {
72119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72120     return 0;
72121   }
72122   arg1 = *argp1;
72123   arg2 = (Dali::Vector3 *)jarg2;
72124   if (!arg2) {
72125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72126     return 0;
72127   }
72128   arg3 = (Dali::Property::Index)jarg3;
72129   arg4 = (Dali::Vector3 *)jarg4;
72130   if (!arg4) {
72131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72132     return 0;
72133   }
72134   arg5 = (unsigned int)jarg5;
72135   {
72136     try {
72137       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72138     } catch (std::out_of_range& e) {
72139       {
72140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72141       };
72142     } catch (std::exception& e) {
72143       {
72144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72145       };
72146     } catch (Dali::DaliException e) {
72147       {
72148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72149       };
72150     } catch (...) {
72151       {
72152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72153       };
72154     }
72155   }
72156
72157   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72158   return jresult;
72159 }
72160
72161
72162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72163   void * jresult ;
72164   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72165
72166   {
72167     try {
72168       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72169     } catch (std::out_of_range& e) {
72170       {
72171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72172       };
72173     } catch (std::exception& e) {
72174       {
72175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72176       };
72177     } catch (Dali::DaliException e) {
72178       {
72179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72180       };
72181     } catch (...) {
72182       {
72183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72184       };
72185     }
72186   }
72187
72188   jresult = (void *)result;
72189   return jresult;
72190 }
72191
72192
72193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72194   void * jresult ;
72195   Dali::BaseHandle arg1 ;
72196   Dali::BaseHandle *argp1 ;
72197   Dali::Toolkit::ScrollViewPagePathEffect result;
72198
72199   argp1 = (Dali::BaseHandle *)jarg1;
72200   if (!argp1) {
72201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72202     return 0;
72203   }
72204   arg1 = *argp1;
72205   {
72206     try {
72207       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72208     } catch (std::out_of_range& e) {
72209       {
72210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72211       };
72212     } catch (std::exception& e) {
72213       {
72214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72215       };
72216     } catch (Dali::DaliException e) {
72217       {
72218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72219       };
72220     } catch (...) {
72221       {
72222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72223       };
72224     }
72225   }
72226
72227   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72228   return jresult;
72229 }
72230
72231
72232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72233   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72234   Dali::Actor arg2 ;
72235   unsigned int arg3 ;
72236   Dali::Actor *argp2 ;
72237
72238   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72239   argp2 = (Dali::Actor *)jarg2;
72240   if (!argp2) {
72241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72242     return ;
72243   }
72244   arg2 = *argp2;
72245   arg3 = (unsigned int)jarg3;
72246   {
72247     try {
72248       (arg1)->ApplyToPage(arg2,arg3);
72249     } catch (std::out_of_range& e) {
72250       {
72251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72252       };
72253     } catch (std::exception& e) {
72254       {
72255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72256       };
72257     } catch (Dali::DaliException e) {
72258       {
72259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72260       };
72261     } catch (...) {
72262       {
72263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72264       };
72265     }
72266   }
72267
72268 }
72269
72270
72271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72272   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72273
72274   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72275   {
72276     try {
72277       delete arg1;
72278     } catch (std::out_of_range& e) {
72279       {
72280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72281       };
72282     } catch (std::exception& e) {
72283       {
72284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72285       };
72286     } catch (Dali::DaliException e) {
72287       {
72288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72289       };
72290     } catch (...) {
72291       {
72292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72293       };
72294     }
72295   }
72296
72297 }
72298
72299
72300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_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)->x = arg2;
72307 }
72308
72309
72310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_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)->x);
72317   jresult = (int)result;
72318   return jresult;
72319 }
72320
72321
72322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72323   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72324   Dali::Toolkit::ClampState arg2 ;
72325
72326   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72327   arg2 = (Dali::Toolkit::ClampState)jarg2;
72328   if (arg1) (arg1)->y = arg2;
72329 }
72330
72331
72332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72333   int jresult ;
72334   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72335   Dali::Toolkit::ClampState result;
72336
72337   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72338   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72339   jresult = (int)result;
72340   return jresult;
72341 }
72342
72343
72344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72345   void * jresult ;
72346   Dali::Toolkit::ClampState2D *result = 0 ;
72347
72348   {
72349     try {
72350       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72351     } catch (std::out_of_range& e) {
72352       {
72353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72354       };
72355     } catch (std::exception& e) {
72356       {
72357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72358       };
72359     } catch (Dali::DaliException e) {
72360       {
72361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72362       };
72363     } catch (...) {
72364       {
72365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72366       };
72367     }
72368   }
72369
72370   jresult = (void *)result;
72371   return jresult;
72372 }
72373
72374
72375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72376   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72377
72378   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72379   {
72380     try {
72381       delete arg1;
72382     } catch (std::out_of_range& e) {
72383       {
72384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72385       };
72386     } catch (std::exception& e) {
72387       {
72388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72389       };
72390     } catch (Dali::DaliException e) {
72391       {
72392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72393       };
72394     } catch (...) {
72395       {
72396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72397       };
72398     }
72399   }
72400
72401 }
72402
72403
72404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72405   void * jresult ;
72406   float arg1 ;
72407   float arg2 ;
72408   bool arg3 ;
72409   Dali::Toolkit::RulerDomain *result = 0 ;
72410
72411   arg1 = (float)jarg1;
72412   arg2 = (float)jarg2;
72413   arg3 = jarg3 ? true : false;
72414   {
72415     try {
72416       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72417     } catch (std::out_of_range& e) {
72418       {
72419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72420       };
72421     } catch (std::exception& e) {
72422       {
72423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72424       };
72425     } catch (Dali::DaliException e) {
72426       {
72427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72428       };
72429     } catch (...) {
72430       {
72431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72432       };
72433     }
72434   }
72435
72436   jresult = (void *)result;
72437   return jresult;
72438 }
72439
72440
72441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72442   void * jresult ;
72443   float arg1 ;
72444   float arg2 ;
72445   Dali::Toolkit::RulerDomain *result = 0 ;
72446
72447   arg1 = (float)jarg1;
72448   arg2 = (float)jarg2;
72449   {
72450     try {
72451       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72452     } catch (std::out_of_range& e) {
72453       {
72454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72455       };
72456     } catch (std::exception& e) {
72457       {
72458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72459       };
72460     } catch (Dali::DaliException e) {
72461       {
72462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72463       };
72464     } catch (...) {
72465       {
72466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72467       };
72468     }
72469   }
72470
72471   jresult = (void *)result;
72472   return jresult;
72473 }
72474
72475
72476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_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)->min = arg2;
72483 }
72484
72485
72486 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_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)->min);
72493   jresult = result;
72494   return jresult;
72495 }
72496
72497
72498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72499   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72500   float arg2 ;
72501
72502   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72503   arg2 = (float)jarg2;
72504   if (arg1) (arg1)->max = arg2;
72505 }
72506
72507
72508 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72509   float jresult ;
72510   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72511   float result;
72512
72513   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72514   result = (float) ((arg1)->max);
72515   jresult = result;
72516   return jresult;
72517 }
72518
72519
72520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72521   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72522   bool arg2 ;
72523
72524   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72525   arg2 = jarg2 ? true : false;
72526   if (arg1) (arg1)->enabled = arg2;
72527 }
72528
72529
72530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72531   unsigned int jresult ;
72532   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72533   bool result;
72534
72535   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72536   result = (bool) ((arg1)->enabled);
72537   jresult = result;
72538   return jresult;
72539 }
72540
72541
72542 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72543   float jresult ;
72544   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72545   float arg2 ;
72546   float arg3 ;
72547   float arg4 ;
72548   float result;
72549
72550   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72551   arg2 = (float)jarg2;
72552   arg3 = (float)jarg3;
72553   arg4 = (float)jarg4;
72554   {
72555     try {
72556       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72557     } catch (std::out_of_range& e) {
72558       {
72559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72560       };
72561     } catch (std::exception& e) {
72562       {
72563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72564       };
72565     } catch (Dali::DaliException e) {
72566       {
72567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72568       };
72569     } catch (...) {
72570       {
72571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72572       };
72573     }
72574   }
72575
72576   jresult = result;
72577   return jresult;
72578 }
72579
72580
72581 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72582   float jresult ;
72583   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72584   float arg2 ;
72585   float arg3 ;
72586   float result;
72587
72588   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72589   arg2 = (float)jarg2;
72590   arg3 = (float)jarg3;
72591   {
72592     try {
72593       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72594     } catch (std::out_of_range& e) {
72595       {
72596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72597       };
72598     } catch (std::exception& e) {
72599       {
72600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72601       };
72602     } catch (Dali::DaliException e) {
72603       {
72604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72605       };
72606     } catch (...) {
72607       {
72608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72609       };
72610     }
72611   }
72612
72613   jresult = result;
72614   return jresult;
72615 }
72616
72617
72618 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72619   float jresult ;
72620   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72621   float arg2 ;
72622   float result;
72623
72624   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72625   arg2 = (float)jarg2;
72626   {
72627     try {
72628       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72629     } catch (std::out_of_range& e) {
72630       {
72631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72632       };
72633     } catch (std::exception& e) {
72634       {
72635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72636       };
72637     } catch (Dali::DaliException e) {
72638       {
72639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72640       };
72641     } catch (...) {
72642       {
72643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72644       };
72645     }
72646   }
72647
72648   jresult = result;
72649   return jresult;
72650 }
72651
72652
72653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72654   float jresult ;
72655   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72656   float arg2 ;
72657   float arg3 ;
72658   float arg4 ;
72659   Dali::Toolkit::ClampState *arg5 = 0 ;
72660   float result;
72661
72662   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72663   arg2 = (float)jarg2;
72664   arg3 = (float)jarg3;
72665   arg4 = (float)jarg4;
72666   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72667   if (!arg5) {
72668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72669     return 0;
72670   }
72671   {
72672     try {
72673       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72674     } catch (std::out_of_range& e) {
72675       {
72676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72677       };
72678     } catch (std::exception& e) {
72679       {
72680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72681       };
72682     } catch (Dali::DaliException e) {
72683       {
72684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72685       };
72686     } catch (...) {
72687       {
72688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72689       };
72690     }
72691   }
72692
72693   jresult = result;
72694   return jresult;
72695 }
72696
72697
72698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
72699   float jresult ;
72700   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72701   float result;
72702
72703   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72704   {
72705     try {
72706       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72707     } catch (std::out_of_range& e) {
72708       {
72709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72710       };
72711     } catch (std::exception& e) {
72712       {
72713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72714       };
72715     } catch (Dali::DaliException e) {
72716       {
72717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72718       };
72719     } catch (...) {
72720       {
72721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72722       };
72723     }
72724   }
72725
72726   jresult = result;
72727   return jresult;
72728 }
72729
72730
72731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72732   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72733
72734   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72735   {
72736     try {
72737       delete arg1;
72738     } catch (std::out_of_range& e) {
72739       {
72740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72741       };
72742     } catch (std::exception& e) {
72743       {
72744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72745       };
72746     } catch (Dali::DaliException e) {
72747       {
72748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72749       };
72750     } catch (...) {
72751       {
72752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72753       };
72754     }
72755   }
72756
72757 }
72758
72759
72760 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72761   float jresult ;
72762   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72763   float arg2 ;
72764   float arg3 ;
72765   float result;
72766
72767   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72768   arg2 = (float)jarg2;
72769   arg3 = (float)jarg3;
72770   {
72771     try {
72772       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72773     } catch (std::out_of_range& e) {
72774       {
72775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72776       };
72777     } catch (std::exception& e) {
72778       {
72779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72780       };
72781     } catch (Dali::DaliException e) {
72782       {
72783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72784       };
72785     } catch (...) {
72786       {
72787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72788       };
72789     }
72790   }
72791
72792   jresult = result;
72793   return jresult;
72794 }
72795
72796
72797 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72798   float jresult ;
72799   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72800   float arg2 ;
72801   float result;
72802
72803   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72804   arg2 = (float)jarg2;
72805   {
72806     try {
72807       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72808     } catch (std::out_of_range& e) {
72809       {
72810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72811       };
72812     } catch (std::exception& e) {
72813       {
72814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72815       };
72816     } catch (Dali::DaliException e) {
72817       {
72818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72819       };
72820     } catch (...) {
72821       {
72822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72823       };
72824     }
72825   }
72826
72827   jresult = result;
72828   return jresult;
72829 }
72830
72831
72832 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72833   float jresult ;
72834   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72835   unsigned int arg2 ;
72836   unsigned int *arg3 = 0 ;
72837   bool arg4 ;
72838   float result;
72839
72840   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72841   arg2 = (unsigned int)jarg2;
72842   arg3 = (unsigned int *)jarg3;
72843   arg4 = jarg4 ? true : false;
72844   {
72845     try {
72846       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72847     } catch (std::out_of_range& e) {
72848       {
72849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72850       };
72851     } catch (std::exception& e) {
72852       {
72853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72854       };
72855     } catch (Dali::DaliException e) {
72856       {
72857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72858       };
72859     } catch (...) {
72860       {
72861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72862       };
72863     }
72864   }
72865
72866   jresult = result;
72867   return jresult;
72868 }
72869
72870
72871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72872   unsigned int jresult ;
72873   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72874   float arg2 ;
72875   bool arg3 ;
72876   unsigned int result;
72877
72878   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72879   arg2 = (float)jarg2;
72880   arg3 = jarg3 ? true : false;
72881   {
72882     try {
72883       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72884     } catch (std::out_of_range& e) {
72885       {
72886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72887       };
72888     } catch (std::exception& e) {
72889       {
72890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72891       };
72892     } catch (Dali::DaliException e) {
72893       {
72894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72895       };
72896     } catch (...) {
72897       {
72898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72899       };
72900     }
72901   }
72902
72903   jresult = result;
72904   return jresult;
72905 }
72906
72907
72908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
72909   unsigned int jresult ;
72910   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72911   unsigned int result;
72912
72913   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72914   {
72915     try {
72916       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
72917     } catch (std::out_of_range& e) {
72918       {
72919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72920       };
72921     } catch (std::exception& e) {
72922       {
72923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72924       };
72925     } catch (Dali::DaliException e) {
72926       {
72927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72928       };
72929     } catch (...) {
72930       {
72931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72932       };
72933     }
72934   }
72935
72936   jresult = result;
72937   return jresult;
72938 }
72939
72940
72941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
72942   int jresult ;
72943   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72944   Dali::Toolkit::Ruler::RulerType result;
72945
72946   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72947   {
72948     try {
72949       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
72950     } catch (std::out_of_range& e) {
72951       {
72952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72953       };
72954     } catch (std::exception& e) {
72955       {
72956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72957       };
72958     } catch (Dali::DaliException e) {
72959       {
72960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72961       };
72962     } catch (...) {
72963       {
72964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72965       };
72966     }
72967   }
72968
72969   jresult = (int)result;
72970   return jresult;
72971 }
72972
72973
72974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
72975   unsigned int jresult ;
72976   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72977   bool result;
72978
72979   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72980   {
72981     try {
72982       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
72983     } catch (std::out_of_range& e) {
72984       {
72985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72986       };
72987     } catch (std::exception& e) {
72988       {
72989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72990       };
72991     } catch (Dali::DaliException e) {
72992       {
72993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72994       };
72995     } catch (...) {
72996       {
72997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72998       };
72999     }
73000   }
73001
73002   jresult = result;
73003   return jresult;
73004 }
73005
73006
73007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
73008   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73009
73010   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73011   {
73012     try {
73013       (arg1)->Enable();
73014     } catch (std::out_of_range& e) {
73015       {
73016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73017       };
73018     } catch (std::exception& e) {
73019       {
73020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73021       };
73022     } catch (Dali::DaliException e) {
73023       {
73024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73025       };
73026     } catch (...) {
73027       {
73028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73029       };
73030     }
73031   }
73032
73033 }
73034
73035
73036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
73037   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73038
73039   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73040   {
73041     try {
73042       (arg1)->Disable();
73043     } catch (std::out_of_range& e) {
73044       {
73045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73046       };
73047     } catch (std::exception& e) {
73048       {
73049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73050       };
73051     } catch (Dali::DaliException e) {
73052       {
73053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73054       };
73055     } catch (...) {
73056       {
73057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73058       };
73059     }
73060   }
73061
73062 }
73063
73064
73065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
73066   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73067   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
73068   Dali::Toolkit::RulerDomain *argp2 ;
73069
73070   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73071   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
73072   if (!argp2) {
73073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
73074     return ;
73075   }
73076   arg2 = *argp2;
73077   {
73078     try {
73079       (arg1)->SetDomain(arg2);
73080     } catch (std::out_of_range& e) {
73081       {
73082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73083       };
73084     } catch (std::exception& e) {
73085       {
73086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73087       };
73088     } catch (Dali::DaliException e) {
73089       {
73090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73091       };
73092     } catch (...) {
73093       {
73094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73095       };
73096     }
73097   }
73098
73099 }
73100
73101
73102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
73103   void * jresult ;
73104   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73105   Dali::Toolkit::RulerDomain *result = 0 ;
73106
73107   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73108   {
73109     try {
73110       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
73111     } catch (std::out_of_range& e) {
73112       {
73113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73114       };
73115     } catch (std::exception& e) {
73116       {
73117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73118       };
73119     } catch (Dali::DaliException e) {
73120       {
73121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73122       };
73123     } catch (...) {
73124       {
73125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73126       };
73127     }
73128   }
73129
73130   jresult = (void *)result;
73131   return jresult;
73132 }
73133
73134
73135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
73136   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73137
73138   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73139   {
73140     try {
73141       (arg1)->DisableDomain();
73142     } catch (std::out_of_range& e) {
73143       {
73144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73145       };
73146     } catch (std::exception& e) {
73147       {
73148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73149       };
73150     } catch (Dali::DaliException e) {
73151       {
73152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73153       };
73154     } catch (...) {
73155       {
73156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73157       };
73158     }
73159   }
73160
73161 }
73162
73163
73164 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
73165   float jresult ;
73166   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73167   float arg2 ;
73168   float arg3 ;
73169   float arg4 ;
73170   float result;
73171
73172   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73173   arg2 = (float)jarg2;
73174   arg3 = (float)jarg3;
73175   arg4 = (float)jarg4;
73176   {
73177     try {
73178       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
73179     } catch (std::out_of_range& e) {
73180       {
73181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73182       };
73183     } catch (std::exception& e) {
73184       {
73185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73186       };
73187     } catch (Dali::DaliException e) {
73188       {
73189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73190       };
73191     } catch (...) {
73192       {
73193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73194       };
73195     }
73196   }
73197
73198   jresult = result;
73199   return jresult;
73200 }
73201
73202
73203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73204   float jresult ;
73205   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73206   float arg2 ;
73207   float arg3 ;
73208   float result;
73209
73210   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73211   arg2 = (float)jarg2;
73212   arg3 = (float)jarg3;
73213   {
73214     try {
73215       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73216     } catch (std::out_of_range& e) {
73217       {
73218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73219       };
73220     } catch (std::exception& e) {
73221       {
73222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73223       };
73224     } catch (Dali::DaliException e) {
73225       {
73226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73227       };
73228     } catch (...) {
73229       {
73230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73231       };
73232     }
73233   }
73234
73235   jresult = result;
73236   return jresult;
73237 }
73238
73239
73240 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73241   float jresult ;
73242   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73243   float arg2 ;
73244   float result;
73245
73246   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73247   arg2 = (float)jarg2;
73248   {
73249     try {
73250       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73251     } catch (std::out_of_range& e) {
73252       {
73253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73254       };
73255     } catch (std::exception& e) {
73256       {
73257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73258       };
73259     } catch (Dali::DaliException e) {
73260       {
73261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73262       };
73263     } catch (...) {
73264       {
73265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73266       };
73267     }
73268   }
73269
73270   jresult = result;
73271   return jresult;
73272 }
73273
73274
73275 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73276   float jresult ;
73277   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73278   float arg2 ;
73279   float arg3 ;
73280   float arg4 ;
73281   Dali::Toolkit::ClampState *arg5 = 0 ;
73282   float result;
73283
73284   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73285   arg2 = (float)jarg2;
73286   arg3 = (float)jarg3;
73287   arg4 = (float)jarg4;
73288   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73289   if (!arg5) {
73290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73291     return 0;
73292   }
73293   {
73294     try {
73295       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73296     } catch (std::out_of_range& e) {
73297       {
73298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73299       };
73300     } catch (std::exception& e) {
73301       {
73302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73303       };
73304     } catch (Dali::DaliException e) {
73305       {
73306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73307       };
73308     } catch (...) {
73309       {
73310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73311       };
73312     }
73313   }
73314
73315   jresult = result;
73316   return jresult;
73317 }
73318
73319
73320 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73321   float jresult ;
73322   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73323   float arg2 ;
73324   float arg3 ;
73325   float arg4 ;
73326   float arg5 ;
73327   float result;
73328
73329   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73330   arg2 = (float)jarg2;
73331   arg3 = (float)jarg3;
73332   arg4 = (float)jarg4;
73333   arg5 = (float)jarg5;
73334   {
73335     try {
73336       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73337     } catch (std::out_of_range& e) {
73338       {
73339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73340       };
73341     } catch (std::exception& e) {
73342       {
73343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73344       };
73345     } catch (Dali::DaliException e) {
73346       {
73347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73348       };
73349     } catch (...) {
73350       {
73351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73352       };
73353     }
73354   }
73355
73356   jresult = result;
73357   return jresult;
73358 }
73359
73360
73361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73362   float jresult ;
73363   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73364   float arg2 ;
73365   float arg3 ;
73366   float arg4 ;
73367   float result;
73368
73369   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73370   arg2 = (float)jarg2;
73371   arg3 = (float)jarg3;
73372   arg4 = (float)jarg4;
73373   {
73374     try {
73375       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
73376     } catch (std::out_of_range& e) {
73377       {
73378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73379       };
73380     } catch (std::exception& e) {
73381       {
73382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73383       };
73384     } catch (Dali::DaliException e) {
73385       {
73386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73387       };
73388     } catch (...) {
73389       {
73390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73391       };
73392     }
73393   }
73394
73395   jresult = result;
73396   return jresult;
73397 }
73398
73399
73400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73401   float jresult ;
73402   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73403   float arg2 ;
73404   float arg3 ;
73405   float result;
73406
73407   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73408   arg2 = (float)jarg2;
73409   arg3 = (float)jarg3;
73410   {
73411     try {
73412       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
73413     } catch (std::out_of_range& e) {
73414       {
73415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73416       };
73417     } catch (std::exception& e) {
73418       {
73419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73420       };
73421     } catch (Dali::DaliException e) {
73422       {
73423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73424       };
73425     } catch (...) {
73426       {
73427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73428       };
73429     }
73430   }
73431
73432   jresult = result;
73433   return jresult;
73434 }
73435
73436
73437 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73438   float jresult ;
73439   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73440   float arg2 ;
73441   float result;
73442
73443   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73444   arg2 = (float)jarg2;
73445   {
73446     try {
73447       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73448     } catch (std::out_of_range& e) {
73449       {
73450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73451       };
73452     } catch (std::exception& e) {
73453       {
73454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73455       };
73456     } catch (Dali::DaliException e) {
73457       {
73458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73459       };
73460     } catch (...) {
73461       {
73462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73463       };
73464     }
73465   }
73466
73467   jresult = result;
73468   return jresult;
73469 }
73470
73471
73472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73473   float jresult ;
73474   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73475   float arg2 ;
73476   float arg3 ;
73477   float arg4 ;
73478   float arg5 ;
73479   Dali::Toolkit::ClampState *arg6 = 0 ;
73480   float result;
73481
73482   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73483   arg2 = (float)jarg2;
73484   arg3 = (float)jarg3;
73485   arg4 = (float)jarg4;
73486   arg5 = (float)jarg5;
73487   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73488   if (!arg6) {
73489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73490     return 0;
73491   }
73492   {
73493     try {
73494       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73495     } catch (std::out_of_range& e) {
73496       {
73497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73498       };
73499     } catch (std::exception& e) {
73500       {
73501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73502       };
73503     } catch (Dali::DaliException e) {
73504       {
73505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73506       };
73507     } catch (...) {
73508       {
73509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73510       };
73511     }
73512   }
73513
73514   jresult = result;
73515   return jresult;
73516 }
73517
73518
73519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73520   void * jresult ;
73521   Dali::Toolkit::DefaultRuler *result = 0 ;
73522
73523   {
73524     try {
73525       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73526     } catch (std::out_of_range& e) {
73527       {
73528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73529       };
73530     } catch (std::exception& e) {
73531       {
73532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73533       };
73534     } catch (Dali::DaliException e) {
73535       {
73536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73537       };
73538     } catch (...) {
73539       {
73540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73541       };
73542     }
73543   }
73544
73545   jresult = (void *)result;
73546   return jresult;
73547 }
73548
73549
73550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73551   float jresult ;
73552   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73553   float arg2 ;
73554   float arg3 ;
73555   float result;
73556
73557   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73558   arg2 = (float)jarg2;
73559   arg3 = (float)jarg3;
73560   {
73561     try {
73562       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73563     } catch (std::out_of_range& e) {
73564       {
73565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73566       };
73567     } catch (std::exception& e) {
73568       {
73569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73570       };
73571     } catch (Dali::DaliException e) {
73572       {
73573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73574       };
73575     } catch (...) {
73576       {
73577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73578       };
73579     }
73580   }
73581
73582   jresult = result;
73583   return jresult;
73584 }
73585
73586
73587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73588   float jresult ;
73589   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73590   unsigned int arg2 ;
73591   unsigned int *arg3 = 0 ;
73592   bool arg4 ;
73593   float result;
73594
73595   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73596   arg2 = (unsigned int)jarg2;
73597   arg3 = (unsigned int *)jarg3;
73598   arg4 = jarg4 ? true : false;
73599   {
73600     try {
73601       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73602     } catch (std::out_of_range& e) {
73603       {
73604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73605       };
73606     } catch (std::exception& e) {
73607       {
73608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73609       };
73610     } catch (Dali::DaliException e) {
73611       {
73612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73613       };
73614     } catch (...) {
73615       {
73616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73617       };
73618     }
73619   }
73620
73621   jresult = result;
73622   return jresult;
73623 }
73624
73625
73626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73627   unsigned int jresult ;
73628   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73629   float arg2 ;
73630   bool arg3 ;
73631   unsigned int result;
73632
73633   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73634   arg2 = (float)jarg2;
73635   arg3 = jarg3 ? true : false;
73636   {
73637     try {
73638       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73639     } catch (std::out_of_range& e) {
73640       {
73641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73642       };
73643     } catch (std::exception& e) {
73644       {
73645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73646       };
73647     } catch (Dali::DaliException e) {
73648       {
73649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73650       };
73651     } catch (...) {
73652       {
73653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73654       };
73655     }
73656   }
73657
73658   jresult = result;
73659   return jresult;
73660 }
73661
73662
73663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73664   unsigned int jresult ;
73665   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73666   unsigned int result;
73667
73668   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73669   {
73670     try {
73671       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73672     } catch (std::out_of_range& e) {
73673       {
73674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73675       };
73676     } catch (std::exception& e) {
73677       {
73678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73679       };
73680     } catch (Dali::DaliException e) {
73681       {
73682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73683       };
73684     } catch (...) {
73685       {
73686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73687       };
73688     }
73689   }
73690
73691   jresult = result;
73692   return jresult;
73693 }
73694
73695
73696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73697   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73698
73699   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73700   {
73701     try {
73702       delete arg1;
73703     } catch (std::out_of_range& e) {
73704       {
73705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73706       };
73707     } catch (std::exception& e) {
73708       {
73709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73710       };
73711     } catch (Dali::DaliException e) {
73712       {
73713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73714       };
73715     } catch (...) {
73716       {
73717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73718       };
73719     }
73720   }
73721
73722 }
73723
73724
73725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73726   void * jresult ;
73727   float arg1 ;
73728   Dali::Toolkit::FixedRuler *result = 0 ;
73729
73730   arg1 = (float)jarg1;
73731   {
73732     try {
73733       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73734     } catch (std::out_of_range& e) {
73735       {
73736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73737       };
73738     } catch (std::exception& e) {
73739       {
73740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73741       };
73742     } catch (Dali::DaliException e) {
73743       {
73744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73745       };
73746     } catch (...) {
73747       {
73748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73749       };
73750     }
73751   }
73752
73753   jresult = (void *)result;
73754   return jresult;
73755 }
73756
73757
73758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
73759   void * jresult ;
73760   Dali::Toolkit::FixedRuler *result = 0 ;
73761
73762   {
73763     try {
73764       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
73765     } catch (std::out_of_range& e) {
73766       {
73767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73768       };
73769     } catch (std::exception& e) {
73770       {
73771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73772       };
73773     } catch (Dali::DaliException e) {
73774       {
73775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73776       };
73777     } catch (...) {
73778       {
73779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73780       };
73781     }
73782   }
73783
73784   jresult = (void *)result;
73785   return jresult;
73786 }
73787
73788
73789 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73790   float jresult ;
73791   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73792   float arg2 ;
73793   float arg3 ;
73794   float result;
73795
73796   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73797   arg2 = (float)jarg2;
73798   arg3 = (float)jarg3;
73799   {
73800     try {
73801       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73802     } catch (std::out_of_range& e) {
73803       {
73804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73805       };
73806     } catch (std::exception& e) {
73807       {
73808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73809       };
73810     } catch (Dali::DaliException e) {
73811       {
73812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73813       };
73814     } catch (...) {
73815       {
73816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73817       };
73818     }
73819   }
73820
73821   jresult = result;
73822   return jresult;
73823 }
73824
73825
73826 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73827   float jresult ;
73828   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73829   unsigned int arg2 ;
73830   unsigned int *arg3 = 0 ;
73831   bool arg4 ;
73832   float result;
73833
73834   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73835   arg2 = (unsigned int)jarg2;
73836   arg3 = (unsigned int *)jarg3;
73837   arg4 = jarg4 ? true : false;
73838   {
73839     try {
73840       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73841     } catch (std::out_of_range& e) {
73842       {
73843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73844       };
73845     } catch (std::exception& e) {
73846       {
73847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73848       };
73849     } catch (Dali::DaliException e) {
73850       {
73851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73852       };
73853     } catch (...) {
73854       {
73855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73856       };
73857     }
73858   }
73859
73860   jresult = result;
73861   return jresult;
73862 }
73863
73864
73865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73866   unsigned int jresult ;
73867   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73868   float arg2 ;
73869   bool arg3 ;
73870   unsigned int result;
73871
73872   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73873   arg2 = (float)jarg2;
73874   arg3 = jarg3 ? true : false;
73875   {
73876     try {
73877       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73878     } catch (std::out_of_range& e) {
73879       {
73880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73881       };
73882     } catch (std::exception& e) {
73883       {
73884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73885       };
73886     } catch (Dali::DaliException e) {
73887       {
73888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73889       };
73890     } catch (...) {
73891       {
73892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73893       };
73894     }
73895   }
73896
73897   jresult = result;
73898   return jresult;
73899 }
73900
73901
73902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
73903   unsigned int jresult ;
73904   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73905   unsigned int result;
73906
73907   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73908   {
73909     try {
73910       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
73911     } catch (std::out_of_range& e) {
73912       {
73913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73914       };
73915     } catch (std::exception& e) {
73916       {
73917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73918       };
73919     } catch (Dali::DaliException e) {
73920       {
73921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73922       };
73923     } catch (...) {
73924       {
73925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73926       };
73927     }
73928   }
73929
73930   jresult = result;
73931   return jresult;
73932 }
73933
73934
73935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
73936   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73937
73938   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73939   {
73940     try {
73941       delete arg1;
73942     } catch (std::out_of_range& e) {
73943       {
73944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73945       };
73946     } catch (std::exception& e) {
73947       {
73948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73949       };
73950     } catch (Dali::DaliException e) {
73951       {
73952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73953       };
73954     } catch (...) {
73955       {
73956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73957       };
73958     }
73959   }
73960
73961 }
73962
73963
73964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_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)->scale = *arg2;
73971 }
73972
73973
73974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_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)->scale);
73981   jresult = (void *)result;
73982   return jresult;
73983 }
73984
73985
73986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
73987   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73988   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73989
73990   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73991   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73992   if (arg1) (arg1)->position = *arg2;
73993 }
73994
73995
73996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
73997   void * jresult ;
73998   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73999   Dali::Toolkit::ClampState2D *result = 0 ;
74000
74001   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74002   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
74003   jresult = (void *)result;
74004   return jresult;
74005 }
74006
74007
74008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
74009   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74010   Dali::Toolkit::ClampState arg2 ;
74011
74012   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74013   arg2 = (Dali::Toolkit::ClampState)jarg2;
74014   if (arg1) (arg1)->rotation = arg2;
74015 }
74016
74017
74018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
74019   int jresult ;
74020   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74021   Dali::Toolkit::ClampState result;
74022
74023   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74024   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
74025   jresult = (int)result;
74026   return jresult;
74027 }
74028
74029
74030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
74031   void * jresult ;
74032   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
74033
74034   {
74035     try {
74036       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
74037     } catch (std::out_of_range& e) {
74038       {
74039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74040       };
74041     } catch (std::exception& e) {
74042       {
74043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74044       };
74045     } catch (Dali::DaliException e) {
74046       {
74047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74048       };
74049     } catch (...) {
74050       {
74051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74052       };
74053     }
74054   }
74055
74056   jresult = (void *)result;
74057   return jresult;
74058 }
74059
74060
74061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
74062   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74063
74064   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74065   {
74066     try {
74067       delete arg1;
74068     } catch (std::out_of_range& e) {
74069       {
74070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74071       };
74072     } catch (std::exception& e) {
74073       {
74074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74075       };
74076     } catch (Dali::DaliException e) {
74077       {
74078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74079       };
74080     } catch (...) {
74081       {
74082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74083       };
74084     }
74085   }
74086
74087 }
74088
74089
74090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
74091   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74092   Dali::Toolkit::SnapType arg2 ;
74093
74094   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74095   arg2 = (Dali::Toolkit::SnapType)jarg2;
74096   if (arg1) (arg1)->type = arg2;
74097 }
74098
74099
74100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
74101   int jresult ;
74102   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74103   Dali::Toolkit::SnapType result;
74104
74105   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74106   result = (Dali::Toolkit::SnapType) ((arg1)->type);
74107   jresult = (int)result;
74108   return jresult;
74109 }
74110
74111
74112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
74113   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74114   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
74115
74116   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74117   arg2 = (Dali::Vector2 *)jarg2;
74118   if (arg1) (arg1)->position = *arg2;
74119 }
74120
74121
74122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
74123   void * jresult ;
74124   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74125   Dali::Vector2 *result = 0 ;
74126
74127   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74128   result = (Dali::Vector2 *)& ((arg1)->position);
74129   jresult = (void *)result;
74130   return jresult;
74131 }
74132
74133
74134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
74135   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74136   float arg2 ;
74137
74138   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74139   arg2 = (float)jarg2;
74140   if (arg1) (arg1)->duration = arg2;
74141 }
74142
74143
74144 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
74145   float jresult ;
74146   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74147   float result;
74148
74149   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74150   result = (float) ((arg1)->duration);
74151   jresult = result;
74152   return jresult;
74153 }
74154
74155
74156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
74157   void * jresult ;
74158   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
74159
74160   {
74161     try {
74162       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
74163     } catch (std::out_of_range& e) {
74164       {
74165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74166       };
74167     } catch (std::exception& e) {
74168       {
74169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74170       };
74171     } catch (Dali::DaliException e) {
74172       {
74173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74174       };
74175     } catch (...) {
74176       {
74177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74178       };
74179     }
74180   }
74181
74182   jresult = (void *)result;
74183   return jresult;
74184 }
74185
74186
74187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
74188   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74189
74190   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74191   {
74192     try {
74193       delete arg1;
74194     } catch (std::out_of_range& e) {
74195       {
74196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74197       };
74198     } catch (std::exception& e) {
74199       {
74200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74201       };
74202     } catch (Dali::DaliException e) {
74203       {
74204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74205       };
74206     } catch (...) {
74207       {
74208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74209       };
74210     }
74211   }
74212
74213 }
74214
74215
74216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
74217   int jresult ;
74218   int result;
74219
74220   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
74221   jresult = (int)result;
74222   return jresult;
74223 }
74224
74225
74226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
74227   int jresult ;
74228   int result;
74229
74230   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
74231   jresult = (int)result;
74232   return jresult;
74233 }
74234
74235
74236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
74237   int jresult ;
74238   int result;
74239
74240   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
74241   jresult = (int)result;
74242   return jresult;
74243 }
74244
74245
74246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74247   int jresult ;
74248   int result;
74249
74250   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74251   jresult = (int)result;
74252   return jresult;
74253 }
74254
74255
74256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
74257   int jresult ;
74258   int result;
74259
74260   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
74261   jresult = (int)result;
74262   return jresult;
74263 }
74264
74265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
74266   int jresult ;
74267   int result;
74268
74269   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
74270   jresult = (int)result;
74271   return jresult;
74272 }
74273
74274
74275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
74276   int jresult ;
74277   int result;
74278
74279   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
74280   jresult = (int)result;
74281   return jresult;
74282 }
74283
74284
74285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
74286   int jresult ;
74287   int result;
74288
74289   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
74290   jresult = (int)result;
74291   return jresult;
74292 }
74293
74294
74295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
74296   int jresult ;
74297   int result;
74298
74299   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
74300   jresult = (int)result;
74301   return jresult;
74302 }
74303
74304
74305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74306   int jresult ;
74307   int result;
74308
74309   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74310   jresult = (int)result;
74311   return jresult;
74312 }
74313
74314
74315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74316   int jresult ;
74317   int result;
74318
74319   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74320   jresult = (int)result;
74321   return jresult;
74322 }
74323
74324
74325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74326   int jresult ;
74327   int result;
74328
74329   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74330   jresult = (int)result;
74331   return jresult;
74332 }
74333
74334
74335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74336   int jresult ;
74337   int result;
74338
74339   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74340   jresult = (int)result;
74341   return jresult;
74342 }
74343
74344
74345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74346   int jresult ;
74347   int result;
74348
74349   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74350   jresult = (int)result;
74351   return jresult;
74352 }
74353
74354
74355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74356   int jresult ;
74357   int result;
74358
74359   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74360   jresult = (int)result;
74361   return jresult;
74362 }
74363
74364
74365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74366   int jresult ;
74367   int result;
74368
74369   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74370   jresult = (int)result;
74371   return jresult;
74372 }
74373
74374
74375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74376   int jresult ;
74377   int result;
74378
74379   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74380   jresult = (int)result;
74381   return jresult;
74382 }
74383
74384
74385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74386   int jresult ;
74387   int result;
74388
74389   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74390   jresult = (int)result;
74391   return jresult;
74392 }
74393
74394
74395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74396   int jresult ;
74397   int result;
74398
74399   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74400   jresult = (int)result;
74401   return jresult;
74402 }
74403
74404
74405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74406   int jresult ;
74407   int result;
74408
74409   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74410   jresult = (int)result;
74411   return jresult;
74412 }
74413
74414
74415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74416   int jresult ;
74417   int result;
74418
74419   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74420   jresult = (int)result;
74421   return jresult;
74422 }
74423
74424
74425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74426   int jresult ;
74427   int result;
74428
74429   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74430   jresult = (int)result;
74431   return jresult;
74432 }
74433
74434
74435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74436   int jresult ;
74437   int result;
74438
74439   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74440   jresult = (int)result;
74441   return jresult;
74442 }
74443
74444
74445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74446   int jresult ;
74447   int result;
74448
74449   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74450   jresult = (int)result;
74451   return jresult;
74452 }
74453
74454
74455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74456   int jresult ;
74457   int result;
74458
74459   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74460   jresult = (int)result;
74461   return jresult;
74462 }
74463
74464
74465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74466   int jresult ;
74467   int result;
74468
74469   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74470   jresult = (int)result;
74471   return jresult;
74472 }
74473
74474
74475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74476   void * jresult ;
74477   Dali::Toolkit::ScrollView::Property *result = 0 ;
74478
74479   {
74480     try {
74481       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74482     } catch (std::out_of_range& e) {
74483       {
74484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74485       };
74486     } catch (std::exception& e) {
74487       {
74488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74489       };
74490     } catch (Dali::DaliException e) {
74491       {
74492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74493       };
74494     } catch (...) {
74495       {
74496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74497       };
74498     }
74499   }
74500
74501   jresult = (void *)result;
74502   return jresult;
74503 }
74504
74505
74506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74507   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74508
74509   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74510   {
74511     try {
74512       delete arg1;
74513     } catch (std::out_of_range& e) {
74514       {
74515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74516       };
74517     } catch (std::exception& e) {
74518       {
74519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74520       };
74521     } catch (Dali::DaliException e) {
74522       {
74523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74524       };
74525     } catch (...) {
74526       {
74527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74528       };
74529     }
74530   }
74531
74532 }
74533
74534
74535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74536   void * jresult ;
74537   Dali::Toolkit::ScrollView *result = 0 ;
74538
74539   {
74540     try {
74541       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74542     } catch (std::out_of_range& e) {
74543       {
74544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74545       };
74546     } catch (std::exception& e) {
74547       {
74548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74549       };
74550     } catch (Dali::DaliException e) {
74551       {
74552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74553       };
74554     } catch (...) {
74555       {
74556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74557       };
74558     }
74559   }
74560
74561   jresult = (void *)result;
74562   return jresult;
74563 }
74564
74565
74566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74567   void * jresult ;
74568   Dali::Toolkit::ScrollView *arg1 = 0 ;
74569   Dali::Toolkit::ScrollView *result = 0 ;
74570
74571   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74572   if (!arg1) {
74573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74574     return 0;
74575   }
74576   {
74577     try {
74578       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74579     } catch (std::out_of_range& e) {
74580       {
74581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74582       };
74583     } catch (std::exception& e) {
74584       {
74585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74586       };
74587     } catch (Dali::DaliException e) {
74588       {
74589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74590       };
74591     } catch (...) {
74592       {
74593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74594       };
74595     }
74596   }
74597
74598   jresult = (void *)result;
74599   return jresult;
74600 }
74601
74602
74603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74604   void * jresult ;
74605   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74606   Dali::Toolkit::ScrollView *arg2 = 0 ;
74607   Dali::Toolkit::ScrollView *result = 0 ;
74608
74609   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74610   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74611   if (!arg2) {
74612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74613     return 0;
74614   }
74615   {
74616     try {
74617       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74618     } catch (std::out_of_range& e) {
74619       {
74620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74621       };
74622     } catch (std::exception& e) {
74623       {
74624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74625       };
74626     } catch (Dali::DaliException e) {
74627       {
74628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74629       };
74630     } catch (...) {
74631       {
74632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74633       };
74634     }
74635   }
74636
74637   jresult = (void *)result;
74638   return jresult;
74639 }
74640
74641
74642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74643   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74644
74645   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74646   {
74647     try {
74648       delete arg1;
74649     } catch (std::out_of_range& e) {
74650       {
74651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74652       };
74653     } catch (std::exception& e) {
74654       {
74655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74656       };
74657     } catch (Dali::DaliException e) {
74658       {
74659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74660       };
74661     } catch (...) {
74662       {
74663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74664       };
74665     }
74666   }
74667
74668 }
74669
74670
74671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74672   void * jresult ;
74673   Dali::Toolkit::ScrollView result;
74674
74675   {
74676     try {
74677       result = Dali::Toolkit::ScrollView::New();
74678     } catch (std::out_of_range& e) {
74679       {
74680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74681       };
74682     } catch (std::exception& e) {
74683       {
74684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74685       };
74686     } catch (Dali::DaliException e) {
74687       {
74688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74689       };
74690     } catch (...) {
74691       {
74692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74693       };
74694     }
74695   }
74696
74697   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74698   return jresult;
74699 }
74700
74701
74702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74703   void * jresult ;
74704   Dali::BaseHandle arg1 ;
74705   Dali::BaseHandle *argp1 ;
74706   Dali::Toolkit::ScrollView result;
74707
74708   argp1 = (Dali::BaseHandle *)jarg1;
74709   if (!argp1) {
74710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74711     return 0;
74712   }
74713   arg1 = *argp1;
74714   {
74715     try {
74716       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74717     } catch (std::out_of_range& e) {
74718       {
74719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74720       };
74721     } catch (std::exception& e) {
74722       {
74723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74724       };
74725     } catch (Dali::DaliException e) {
74726       {
74727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74728       };
74729     } catch (...) {
74730       {
74731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74732       };
74733     }
74734   }
74735
74736   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74737   return jresult;
74738 }
74739
74740
74741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74742   void * jresult ;
74743   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74744   Dali::AlphaFunction result;
74745
74746   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74747   {
74748     try {
74749       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74750     } catch (std::out_of_range& e) {
74751       {
74752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74753       };
74754     } catch (std::exception& e) {
74755       {
74756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74757       };
74758     } catch (Dali::DaliException e) {
74759       {
74760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74761       };
74762     } catch (...) {
74763       {
74764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74765       };
74766     }
74767   }
74768
74769   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74770   return jresult;
74771 }
74772
74773
74774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74775   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74776   Dali::AlphaFunction arg2 ;
74777   Dali::AlphaFunction *argp2 ;
74778
74779   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74780   argp2 = (Dali::AlphaFunction *)jarg2;
74781   if (!argp2) {
74782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74783     return ;
74784   }
74785   arg2 = *argp2;
74786   {
74787     try {
74788       (arg1)->SetScrollSnapAlphaFunction(arg2);
74789     } catch (std::out_of_range& e) {
74790       {
74791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74792       };
74793     } catch (std::exception& e) {
74794       {
74795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74796       };
74797     } catch (Dali::DaliException e) {
74798       {
74799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74800       };
74801     } catch (...) {
74802       {
74803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74804       };
74805     }
74806   }
74807
74808 }
74809
74810
74811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74812   void * jresult ;
74813   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74814   Dali::AlphaFunction result;
74815
74816   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74817   {
74818     try {
74819       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
74820     } catch (std::out_of_range& e) {
74821       {
74822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74823       };
74824     } catch (std::exception& e) {
74825       {
74826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74827       };
74828     } catch (Dali::DaliException e) {
74829       {
74830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74831       };
74832     } catch (...) {
74833       {
74834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74835       };
74836     }
74837   }
74838
74839   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74840   return jresult;
74841 }
74842
74843
74844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74845   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74846   Dali::AlphaFunction arg2 ;
74847   Dali::AlphaFunction *argp2 ;
74848
74849   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74850   argp2 = (Dali::AlphaFunction *)jarg2;
74851   if (!argp2) {
74852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74853     return ;
74854   }
74855   arg2 = *argp2;
74856   {
74857     try {
74858       (arg1)->SetScrollFlickAlphaFunction(arg2);
74859     } catch (std::out_of_range& e) {
74860       {
74861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74862       };
74863     } catch (std::exception& e) {
74864       {
74865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74866       };
74867     } catch (Dali::DaliException e) {
74868       {
74869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74870       };
74871     } catch (...) {
74872       {
74873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74874       };
74875     }
74876   }
74877
74878 }
74879
74880
74881 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
74882   float jresult ;
74883   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74884   float result;
74885
74886   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74887   {
74888     try {
74889       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
74890     } catch (std::out_of_range& e) {
74891       {
74892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74893       };
74894     } catch (std::exception& e) {
74895       {
74896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74897       };
74898     } catch (Dali::DaliException e) {
74899       {
74900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74901       };
74902     } catch (...) {
74903       {
74904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74905       };
74906     }
74907   }
74908
74909   jresult = result;
74910   return jresult;
74911 }
74912
74913
74914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
74915   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74916   float arg2 ;
74917
74918   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74919   arg2 = (float)jarg2;
74920   {
74921     try {
74922       (arg1)->SetScrollSnapDuration(arg2);
74923     } catch (std::out_of_range& e) {
74924       {
74925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74926       };
74927     } catch (std::exception& e) {
74928       {
74929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74930       };
74931     } catch (Dali::DaliException e) {
74932       {
74933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74934       };
74935     } catch (...) {
74936       {
74937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74938       };
74939     }
74940   }
74941
74942 }
74943
74944
74945 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
74946   float jresult ;
74947   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74948   float result;
74949
74950   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74951   {
74952     try {
74953       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
74954     } catch (std::out_of_range& e) {
74955       {
74956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74957       };
74958     } catch (std::exception& e) {
74959       {
74960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74961       };
74962     } catch (Dali::DaliException e) {
74963       {
74964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74965       };
74966     } catch (...) {
74967       {
74968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74969       };
74970     }
74971   }
74972
74973   jresult = result;
74974   return jresult;
74975 }
74976
74977
74978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
74979   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74980   float arg2 ;
74981
74982   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74983   arg2 = (float)jarg2;
74984   {
74985     try {
74986       (arg1)->SetScrollFlickDuration(arg2);
74987     } catch (std::out_of_range& e) {
74988       {
74989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74990       };
74991     } catch (std::exception& e) {
74992       {
74993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74994       };
74995     } catch (Dali::DaliException e) {
74996       {
74997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74998       };
74999     } catch (...) {
75000       {
75001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75002       };
75003     }
75004   }
75005
75006 }
75007
75008
75009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
75010   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75011   Dali::Toolkit::RulerPtr arg2 ;
75012   Dali::Toolkit::RulerPtr *argp2 ;
75013
75014   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75015   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
75016   if (!argp2) {
75017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
75018     return ;
75019   }
75020   arg2 = *argp2;
75021   {
75022     try {
75023       (arg1)->SetRulerX(arg2);
75024     } catch (std::out_of_range& e) {
75025       {
75026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75027       };
75028     } catch (std::exception& e) {
75029       {
75030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75031       };
75032     } catch (Dali::DaliException e) {
75033       {
75034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75035       };
75036     } catch (...) {
75037       {
75038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75039       };
75040     }
75041   }
75042
75043 }
75044
75045
75046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
75047   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75048   Dali::Toolkit::RulerPtr arg2 ;
75049   Dali::Toolkit::RulerPtr *argp2 ;
75050
75051   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75052   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
75053   if (!argp2) {
75054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
75055     return ;
75056   }
75057   arg2 = *argp2;
75058   {
75059     try {
75060       (arg1)->SetRulerY(arg2);
75061     } catch (std::out_of_range& e) {
75062       {
75063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75064       };
75065     } catch (std::exception& e) {
75066       {
75067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75068       };
75069     } catch (Dali::DaliException e) {
75070       {
75071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75072       };
75073     } catch (...) {
75074       {
75075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75076       };
75077     }
75078   }
75079
75080 }
75081
75082
75083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
75084   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75085   bool arg2 ;
75086
75087   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75088   arg2 = jarg2 ? true : false;
75089   {
75090     try {
75091       (arg1)->SetScrollSensitive(arg2);
75092     } catch (std::out_of_range& e) {
75093       {
75094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75095       };
75096     } catch (std::exception& e) {
75097       {
75098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75099       };
75100     } catch (Dali::DaliException e) {
75101       {
75102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75103       };
75104     } catch (...) {
75105       {
75106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75107       };
75108     }
75109   }
75110
75111 }
75112
75113
75114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
75115   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75116   float arg2 ;
75117   float arg3 ;
75118
75119   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75120   arg2 = (float)jarg2;
75121   arg3 = (float)jarg3;
75122   {
75123     try {
75124       (arg1)->SetMaxOvershoot(arg2,arg3);
75125     } catch (std::out_of_range& e) {
75126       {
75127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75128       };
75129     } catch (std::exception& e) {
75130       {
75131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75132       };
75133     } catch (Dali::DaliException e) {
75134       {
75135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75136       };
75137     } catch (...) {
75138       {
75139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75140       };
75141     }
75142   }
75143
75144 }
75145
75146
75147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
75148   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75149   Dali::AlphaFunction arg2 ;
75150   Dali::AlphaFunction *argp2 ;
75151
75152   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75153   argp2 = (Dali::AlphaFunction *)jarg2;
75154   if (!argp2) {
75155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75156     return ;
75157   }
75158   arg2 = *argp2;
75159   {
75160     try {
75161       (arg1)->SetSnapOvershootAlphaFunction(arg2);
75162     } catch (std::out_of_range& e) {
75163       {
75164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75165       };
75166     } catch (std::exception& e) {
75167       {
75168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75169       };
75170     } catch (Dali::DaliException e) {
75171       {
75172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75173       };
75174     } catch (...) {
75175       {
75176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75177       };
75178     }
75179   }
75180
75181 }
75182
75183
75184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
75185   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75186   float arg2 ;
75187
75188   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75189   arg2 = (float)jarg2;
75190   {
75191     try {
75192       (arg1)->SetSnapOvershootDuration(arg2);
75193     } catch (std::out_of_range& e) {
75194       {
75195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75196       };
75197     } catch (std::exception& e) {
75198       {
75199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75200       };
75201     } catch (Dali::DaliException e) {
75202       {
75203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75204       };
75205     } catch (...) {
75206       {
75207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75208       };
75209     }
75210   }
75211
75212 }
75213
75214
75215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
75216   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75217   bool arg2 ;
75218
75219   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75220   arg2 = jarg2 ? true : false;
75221   {
75222     try {
75223       (arg1)->SetActorAutoSnap(arg2);
75224     } catch (std::out_of_range& e) {
75225       {
75226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75227       };
75228     } catch (std::exception& e) {
75229       {
75230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75231       };
75232     } catch (Dali::DaliException e) {
75233       {
75234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75235       };
75236     } catch (...) {
75237       {
75238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75239       };
75240     }
75241   }
75242
75243 }
75244
75245
75246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
75247   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75248   bool arg2 ;
75249
75250   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75251   arg2 = jarg2 ? true : false;
75252   {
75253     try {
75254       (arg1)->SetWrapMode(arg2);
75255     } catch (std::out_of_range& e) {
75256       {
75257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75258       };
75259     } catch (std::exception& e) {
75260       {
75261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75262       };
75263     } catch (Dali::DaliException e) {
75264       {
75265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75266       };
75267     } catch (...) {
75268       {
75269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75270       };
75271     }
75272   }
75273
75274 }
75275
75276
75277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
75278   int jresult ;
75279   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75280   int result;
75281
75282   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75283   {
75284     try {
75285       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
75286     } catch (std::out_of_range& e) {
75287       {
75288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75289       };
75290     } catch (std::exception& e) {
75291       {
75292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75293       };
75294     } catch (Dali::DaliException e) {
75295       {
75296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75297       };
75298     } catch (...) {
75299       {
75300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75301       };
75302     }
75303   }
75304
75305   jresult = result;
75306   return jresult;
75307 }
75308
75309
75310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
75311   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75312   int arg2 ;
75313
75314   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75315   arg2 = (int)jarg2;
75316   {
75317     try {
75318       (arg1)->SetScrollUpdateDistance(arg2);
75319     } catch (std::out_of_range& e) {
75320       {
75321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75322       };
75323     } catch (std::exception& e) {
75324       {
75325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75326       };
75327     } catch (Dali::DaliException e) {
75328       {
75329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75330       };
75331     } catch (...) {
75332       {
75333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75334       };
75335     }
75336   }
75337
75338 }
75339
75340
75341 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
75342   unsigned int jresult ;
75343   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75344   bool result;
75345
75346   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75347   {
75348     try {
75349       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
75350     } catch (std::out_of_range& e) {
75351       {
75352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75353       };
75354     } catch (std::exception& e) {
75355       {
75356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75357       };
75358     } catch (Dali::DaliException e) {
75359       {
75360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75361       };
75362     } catch (...) {
75363       {
75364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75365       };
75366     }
75367   }
75368
75369   jresult = result;
75370   return jresult;
75371 }
75372
75373
75374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
75375   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75376   bool arg2 ;
75377
75378   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75379   arg2 = jarg2 ? true : false;
75380   {
75381     try {
75382       (arg1)->SetAxisAutoLock(arg2);
75383     } catch (std::out_of_range& e) {
75384       {
75385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75386       };
75387     } catch (std::exception& e) {
75388       {
75389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75390       };
75391     } catch (Dali::DaliException e) {
75392       {
75393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75394       };
75395     } catch (...) {
75396       {
75397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75398       };
75399     }
75400   }
75401
75402 }
75403
75404
75405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
75406   float jresult ;
75407   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75408   float result;
75409
75410   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75411   {
75412     try {
75413       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
75414     } catch (std::out_of_range& e) {
75415       {
75416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75417       };
75418     } catch (std::exception& e) {
75419       {
75420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75421       };
75422     } catch (Dali::DaliException e) {
75423       {
75424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75425       };
75426     } catch (...) {
75427       {
75428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75429       };
75430     }
75431   }
75432
75433   jresult = result;
75434   return jresult;
75435 }
75436
75437
75438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
75439   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75440   float arg2 ;
75441
75442   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75443   arg2 = (float)jarg2;
75444   {
75445     try {
75446       (arg1)->SetAxisAutoLockGradient(arg2);
75447     } catch (std::out_of_range& e) {
75448       {
75449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75450       };
75451     } catch (std::exception& e) {
75452       {
75453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75454       };
75455     } catch (Dali::DaliException e) {
75456       {
75457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75458       };
75459     } catch (...) {
75460       {
75461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75462       };
75463     }
75464   }
75465
75466 }
75467
75468
75469 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
75470   float jresult ;
75471   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75472   float result;
75473
75474   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75475   {
75476     try {
75477       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75478     } catch (std::out_of_range& e) {
75479       {
75480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75481       };
75482     } catch (std::exception& e) {
75483       {
75484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75485       };
75486     } catch (Dali::DaliException e) {
75487       {
75488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75489       };
75490     } catch (...) {
75491       {
75492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75493       };
75494     }
75495   }
75496
75497   jresult = result;
75498   return jresult;
75499 }
75500
75501
75502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75503   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75504   float arg2 ;
75505
75506   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75507   arg2 = (float)jarg2;
75508   {
75509     try {
75510       (arg1)->SetFrictionCoefficient(arg2);
75511     } catch (std::out_of_range& e) {
75512       {
75513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75514       };
75515     } catch (std::exception& e) {
75516       {
75517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75518       };
75519     } catch (Dali::DaliException e) {
75520       {
75521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75522       };
75523     } catch (...) {
75524       {
75525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75526       };
75527     }
75528   }
75529
75530 }
75531
75532
75533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75534   float jresult ;
75535   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75536   float result;
75537
75538   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75539   {
75540     try {
75541       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75542     } catch (std::out_of_range& e) {
75543       {
75544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75545       };
75546     } catch (std::exception& e) {
75547       {
75548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75549       };
75550     } catch (Dali::DaliException e) {
75551       {
75552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75553       };
75554     } catch (...) {
75555       {
75556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75557       };
75558     }
75559   }
75560
75561   jresult = result;
75562   return jresult;
75563 }
75564
75565
75566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75567   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75568   float arg2 ;
75569
75570   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75571   arg2 = (float)jarg2;
75572   {
75573     try {
75574       (arg1)->SetFlickSpeedCoefficient(arg2);
75575     } catch (std::out_of_range& e) {
75576       {
75577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75578       };
75579     } catch (std::exception& e) {
75580       {
75581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75582       };
75583     } catch (Dali::DaliException e) {
75584       {
75585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75586       };
75587     } catch (...) {
75588       {
75589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75590       };
75591     }
75592   }
75593
75594 }
75595
75596
75597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75598   void * jresult ;
75599   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75600   Dali::Vector2 result;
75601
75602   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75603   {
75604     try {
75605       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75606     } catch (std::out_of_range& e) {
75607       {
75608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75609       };
75610     } catch (std::exception& e) {
75611       {
75612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75613       };
75614     } catch (Dali::DaliException e) {
75615       {
75616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75617       };
75618     } catch (...) {
75619       {
75620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75621       };
75622     }
75623   }
75624
75625   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75626   return jresult;
75627 }
75628
75629
75630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75631   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75632   Dali::Vector2 *arg2 = 0 ;
75633
75634   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75635   arg2 = (Dali::Vector2 *)jarg2;
75636   if (!arg2) {
75637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75638     return ;
75639   }
75640   {
75641     try {
75642       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75643     } catch (std::out_of_range& e) {
75644       {
75645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75646       };
75647     } catch (std::exception& e) {
75648       {
75649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75650       };
75651     } catch (Dali::DaliException e) {
75652       {
75653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75654       };
75655     } catch (...) {
75656       {
75657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75658       };
75659     }
75660   }
75661
75662 }
75663
75664
75665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75666   float jresult ;
75667   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75668   float result;
75669
75670   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75671   {
75672     try {
75673       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75674     } catch (std::out_of_range& e) {
75675       {
75676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75677       };
75678     } catch (std::exception& e) {
75679       {
75680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75681       };
75682     } catch (Dali::DaliException e) {
75683       {
75684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75685       };
75686     } catch (...) {
75687       {
75688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75689       };
75690     }
75691   }
75692
75693   jresult = result;
75694   return jresult;
75695 }
75696
75697
75698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75699   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75700   float arg2 ;
75701
75702   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75703   arg2 = (float)jarg2;
75704   {
75705     try {
75706       (arg1)->SetMinimumSpeedForFlick(arg2);
75707     } catch (std::out_of_range& e) {
75708       {
75709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75710       };
75711     } catch (std::exception& e) {
75712       {
75713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75714       };
75715     } catch (Dali::DaliException e) {
75716       {
75717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75718       };
75719     } catch (...) {
75720       {
75721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75722       };
75723     }
75724   }
75725
75726 }
75727
75728
75729 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75730   float jresult ;
75731   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75732   float result;
75733
75734   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75735   {
75736     try {
75737       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
75738     } catch (std::out_of_range& e) {
75739       {
75740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75741       };
75742     } catch (std::exception& e) {
75743       {
75744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75745       };
75746     } catch (Dali::DaliException e) {
75747       {
75748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75749       };
75750     } catch (...) {
75751       {
75752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75753       };
75754     }
75755   }
75756
75757   jresult = result;
75758   return jresult;
75759 }
75760
75761
75762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75763   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75764   float arg2 ;
75765
75766   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75767   arg2 = (float)jarg2;
75768   {
75769     try {
75770       (arg1)->SetMaxFlickSpeed(arg2);
75771     } catch (std::out_of_range& e) {
75772       {
75773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75774       };
75775     } catch (std::exception& e) {
75776       {
75777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75778       };
75779     } catch (Dali::DaliException e) {
75780       {
75781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75782       };
75783     } catch (...) {
75784       {
75785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75786       };
75787     }
75788   }
75789
75790 }
75791
75792
75793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75794   void * jresult ;
75795   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75796   Dali::Vector2 result;
75797
75798   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75799   {
75800     try {
75801       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75802     } catch (std::out_of_range& e) {
75803       {
75804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75805       };
75806     } catch (std::exception& e) {
75807       {
75808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75809       };
75810     } catch (Dali::DaliException e) {
75811       {
75812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75813       };
75814     } catch (...) {
75815       {
75816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75817       };
75818     }
75819   }
75820
75821   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75822   return jresult;
75823 }
75824
75825
75826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75827   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75828   Dali::Vector2 arg2 ;
75829   Dali::Vector2 *argp2 ;
75830
75831   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75832   argp2 = (Dali::Vector2 *)jarg2;
75833   if (!argp2) {
75834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75835     return ;
75836   }
75837   arg2 = *argp2;
75838   {
75839     try {
75840       (arg1)->SetWheelScrollDistanceStep(arg2);
75841     } catch (std::out_of_range& e) {
75842       {
75843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75844       };
75845     } catch (std::exception& e) {
75846       {
75847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75848       };
75849     } catch (Dali::DaliException e) {
75850       {
75851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75852       };
75853     } catch (...) {
75854       {
75855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75856       };
75857     }
75858   }
75859
75860 }
75861
75862
75863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
75864   void * jresult ;
75865   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75866   Dali::Vector2 result;
75867
75868   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75869   {
75870     try {
75871       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
75872     } catch (std::out_of_range& e) {
75873       {
75874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75875       };
75876     } catch (std::exception& e) {
75877       {
75878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75879       };
75880     } catch (Dali::DaliException e) {
75881       {
75882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75883       };
75884     } catch (...) {
75885       {
75886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75887       };
75888     }
75889   }
75890
75891   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75892   return jresult;
75893 }
75894
75895
75896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
75897   unsigned int jresult ;
75898   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75899   unsigned int result;
75900
75901   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75902   {
75903     try {
75904       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
75905     } catch (std::out_of_range& e) {
75906       {
75907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75908       };
75909     } catch (std::exception& e) {
75910       {
75911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75912       };
75913     } catch (Dali::DaliException e) {
75914       {
75915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75916       };
75917     } catch (...) {
75918       {
75919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75920       };
75921     }
75922   }
75923
75924   jresult = result;
75925   return jresult;
75926 }
75927
75928
75929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
75930   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75931   Dali::Vector2 *arg2 = 0 ;
75932
75933   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75934   arg2 = (Dali::Vector2 *)jarg2;
75935   if (!arg2) {
75936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75937     return ;
75938   }
75939   {
75940     try {
75941       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
75942     } catch (std::out_of_range& e) {
75943       {
75944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75945       };
75946     } catch (std::exception& e) {
75947       {
75948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75949       };
75950     } catch (Dali::DaliException e) {
75951       {
75952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75953       };
75954     } catch (...) {
75955       {
75956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75957       };
75958     }
75959   }
75960
75961 }
75962
75963
75964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
75965   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75966   Dali::Vector2 *arg2 = 0 ;
75967   float arg3 ;
75968
75969   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75970   arg2 = (Dali::Vector2 *)jarg2;
75971   if (!arg2) {
75972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75973     return ;
75974   }
75975   arg3 = (float)jarg3;
75976   {
75977     try {
75978       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
75979     } catch (std::out_of_range& e) {
75980       {
75981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75982       };
75983     } catch (std::exception& e) {
75984       {
75985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75986       };
75987     } catch (Dali::DaliException e) {
75988       {
75989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75990       };
75991     } catch (...) {
75992       {
75993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75994       };
75995     }
75996   }
75997
75998 }
75999
76000
76001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
76002   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76003   Dali::Vector2 *arg2 = 0 ;
76004   float arg3 ;
76005   Dali::AlphaFunction arg4 ;
76006   Dali::AlphaFunction *argp4 ;
76007
76008   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76009   arg2 = (Dali::Vector2 *)jarg2;
76010   if (!arg2) {
76011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76012     return ;
76013   }
76014   arg3 = (float)jarg3;
76015   argp4 = (Dali::AlphaFunction *)jarg4;
76016   if (!argp4) {
76017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76018     return ;
76019   }
76020   arg4 = *argp4;
76021   {
76022     try {
76023       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
76024     } catch (std::out_of_range& e) {
76025       {
76026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76027       };
76028     } catch (std::exception& e) {
76029       {
76030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76031       };
76032     } catch (Dali::DaliException e) {
76033       {
76034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76035       };
76036     } catch (...) {
76037       {
76038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76039       };
76040     }
76041   }
76042
76043 }
76044
76045
76046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
76047   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76048   Dali::Vector2 *arg2 = 0 ;
76049   float arg3 ;
76050   Dali::Toolkit::DirectionBias arg4 ;
76051   Dali::Toolkit::DirectionBias arg5 ;
76052
76053   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76054   arg2 = (Dali::Vector2 *)jarg2;
76055   if (!arg2) {
76056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76057     return ;
76058   }
76059   arg3 = (float)jarg3;
76060   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76061   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76062   {
76063     try {
76064       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
76065     } catch (std::out_of_range& e) {
76066       {
76067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76068       };
76069     } catch (std::exception& e) {
76070       {
76071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76072       };
76073     } catch (Dali::DaliException e) {
76074       {
76075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76076       };
76077     } catch (...) {
76078       {
76079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76080       };
76081     }
76082   }
76083
76084 }
76085
76086
76087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
76088   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76089   Dali::Vector2 *arg2 = 0 ;
76090   float arg3 ;
76091   Dali::AlphaFunction arg4 ;
76092   Dali::Toolkit::DirectionBias arg5 ;
76093   Dali::Toolkit::DirectionBias arg6 ;
76094   Dali::AlphaFunction *argp4 ;
76095
76096   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76097   arg2 = (Dali::Vector2 *)jarg2;
76098   if (!arg2) {
76099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76100     return ;
76101   }
76102   arg3 = (float)jarg3;
76103   argp4 = (Dali::AlphaFunction *)jarg4;
76104   if (!argp4) {
76105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76106     return ;
76107   }
76108   arg4 = *argp4;
76109   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76110   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
76111   {
76112     try {
76113       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
76114     } catch (std::out_of_range& e) {
76115       {
76116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76117       };
76118     } catch (std::exception& e) {
76119       {
76120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76121       };
76122     } catch (Dali::DaliException e) {
76123       {
76124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76125       };
76126     } catch (...) {
76127       {
76128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76129       };
76130     }
76131   }
76132
76133 }
76134
76135
76136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
76137   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76138   unsigned int arg2 ;
76139
76140   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76141   arg2 = (unsigned int)jarg2;
76142   {
76143     try {
76144       (arg1)->ScrollTo(arg2);
76145     } catch (std::out_of_range& e) {
76146       {
76147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76148       };
76149     } catch (std::exception& e) {
76150       {
76151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76152       };
76153     } catch (Dali::DaliException e) {
76154       {
76155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76156       };
76157     } catch (...) {
76158       {
76159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76160       };
76161     }
76162   }
76163
76164 }
76165
76166
76167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
76168   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76169   unsigned int arg2 ;
76170   float arg3 ;
76171
76172   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76173   arg2 = (unsigned int)jarg2;
76174   arg3 = (float)jarg3;
76175   {
76176     try {
76177       (arg1)->ScrollTo(arg2,arg3);
76178     } catch (std::out_of_range& e) {
76179       {
76180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76181       };
76182     } catch (std::exception& e) {
76183       {
76184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76185       };
76186     } catch (Dali::DaliException e) {
76187       {
76188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76189       };
76190     } catch (...) {
76191       {
76192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76193       };
76194     }
76195   }
76196
76197 }
76198
76199
76200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
76201   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76202   unsigned int arg2 ;
76203   float arg3 ;
76204   Dali::Toolkit::DirectionBias arg4 ;
76205
76206   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76207   arg2 = (unsigned int)jarg2;
76208   arg3 = (float)jarg3;
76209   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76210   {
76211     try {
76212       (arg1)->ScrollTo(arg2,arg3,arg4);
76213     } catch (std::out_of_range& e) {
76214       {
76215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76216       };
76217     } catch (std::exception& e) {
76218       {
76219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76220       };
76221     } catch (Dali::DaliException e) {
76222       {
76223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76224       };
76225     } catch (...) {
76226       {
76227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76228       };
76229     }
76230   }
76231
76232 }
76233
76234
76235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
76236   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76237   Dali::Actor *arg2 = 0 ;
76238
76239   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76240   arg2 = (Dali::Actor *)jarg2;
76241   if (!arg2) {
76242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76243     return ;
76244   }
76245   {
76246     try {
76247       (arg1)->ScrollTo(*arg2);
76248     } catch (std::out_of_range& e) {
76249       {
76250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76251       };
76252     } catch (std::exception& e) {
76253       {
76254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76255       };
76256     } catch (Dali::DaliException e) {
76257       {
76258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76259       };
76260     } catch (...) {
76261       {
76262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76263       };
76264     }
76265   }
76266
76267 }
76268
76269
76270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
76271   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76272   Dali::Actor *arg2 = 0 ;
76273   float arg3 ;
76274
76275   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76276   arg2 = (Dali::Actor *)jarg2;
76277   if (!arg2) {
76278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76279     return ;
76280   }
76281   arg3 = (float)jarg3;
76282   {
76283     try {
76284       (arg1)->ScrollTo(*arg2,arg3);
76285     } catch (std::out_of_range& e) {
76286       {
76287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76288       };
76289     } catch (std::exception& e) {
76290       {
76291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76292       };
76293     } catch (Dali::DaliException e) {
76294       {
76295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76296       };
76297     } catch (...) {
76298       {
76299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76300       };
76301     }
76302   }
76303
76304 }
76305
76306
76307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
76308   unsigned int jresult ;
76309   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76310   bool result;
76311
76312   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76313   {
76314     try {
76315       result = (bool)(arg1)->ScrollToSnapPoint();
76316     } catch (std::out_of_range& e) {
76317       {
76318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76319       };
76320     } catch (std::exception& e) {
76321       {
76322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76323       };
76324     } catch (Dali::DaliException e) {
76325       {
76326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76327       };
76328     } catch (...) {
76329       {
76330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76331       };
76332     }
76333   }
76334
76335   jresult = result;
76336   return jresult;
76337 }
76338
76339
76340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
76341   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76342   Dali::Constraint arg2 ;
76343   Dali::Constraint *argp2 ;
76344
76345   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76346   argp2 = (Dali::Constraint *)jarg2;
76347   if (!argp2) {
76348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
76349     return ;
76350   }
76351   arg2 = *argp2;
76352   {
76353     try {
76354       (arg1)->ApplyConstraintToChildren(arg2);
76355     } catch (std::out_of_range& e) {
76356       {
76357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76358       };
76359     } catch (std::exception& e) {
76360       {
76361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76362       };
76363     } catch (Dali::DaliException e) {
76364       {
76365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76366       };
76367     } catch (...) {
76368       {
76369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76370       };
76371     }
76372   }
76373
76374 }
76375
76376
76377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
76378   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76379
76380   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76381   {
76382     try {
76383       (arg1)->RemoveConstraintsFromChildren();
76384     } catch (std::out_of_range& e) {
76385       {
76386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76387       };
76388     } catch (std::exception& e) {
76389       {
76390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76391       };
76392     } catch (Dali::DaliException e) {
76393       {
76394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76395       };
76396     } catch (...) {
76397       {
76398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76399       };
76400     }
76401   }
76402
76403 }
76404
76405
76406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
76407   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76408   Dali::Toolkit::ScrollViewEffect arg2 ;
76409   Dali::Toolkit::ScrollViewEffect *argp2 ;
76410
76411   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76412   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76413   if (!argp2) {
76414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76415     return ;
76416   }
76417   arg2 = *argp2;
76418   {
76419     try {
76420       (arg1)->ApplyEffect(arg2);
76421     } catch (std::out_of_range& e) {
76422       {
76423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76424       };
76425     } catch (std::exception& e) {
76426       {
76427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76428       };
76429     } catch (Dali::DaliException e) {
76430       {
76431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76432       };
76433     } catch (...) {
76434       {
76435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76436       };
76437     }
76438   }
76439
76440 }
76441
76442
76443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
76444   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76445   Dali::Toolkit::ScrollViewEffect arg2 ;
76446   Dali::Toolkit::ScrollViewEffect *argp2 ;
76447
76448   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76449   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76450   if (!argp2) {
76451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76452     return ;
76453   }
76454   arg2 = *argp2;
76455   {
76456     try {
76457       (arg1)->RemoveEffect(arg2);
76458     } catch (std::out_of_range& e) {
76459       {
76460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76461       };
76462     } catch (std::exception& e) {
76463       {
76464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76465       };
76466     } catch (Dali::DaliException e) {
76467       {
76468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76469       };
76470     } catch (...) {
76471       {
76472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76473       };
76474     }
76475   }
76476
76477 }
76478
76479
76480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
76481   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76482
76483   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76484   {
76485     try {
76486       (arg1)->RemoveAllEffects();
76487     } catch (std::out_of_range& e) {
76488       {
76489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76490       };
76491     } catch (std::exception& e) {
76492       {
76493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76494       };
76495     } catch (Dali::DaliException e) {
76496       {
76497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76498       };
76499     } catch (...) {
76500       {
76501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76502       };
76503     }
76504   }
76505
76506 }
76507
76508
76509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
76510   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76511   Dali::Actor arg2 ;
76512   Dali::Actor *argp2 ;
76513
76514   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76515   argp2 = (Dali::Actor *)jarg2;
76516   if (!argp2) {
76517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76518     return ;
76519   }
76520   arg2 = *argp2;
76521   {
76522     try {
76523       (arg1)->BindActor(arg2);
76524     } catch (std::out_of_range& e) {
76525       {
76526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76527       };
76528     } catch (std::exception& e) {
76529       {
76530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76531       };
76532     } catch (Dali::DaliException e) {
76533       {
76534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76535       };
76536     } catch (...) {
76537       {
76538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76539       };
76540     }
76541   }
76542
76543 }
76544
76545
76546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
76547   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76548   Dali::Actor arg2 ;
76549   Dali::Actor *argp2 ;
76550
76551   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76552   argp2 = (Dali::Actor *)jarg2;
76553   if (!argp2) {
76554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76555     return ;
76556   }
76557   arg2 = *argp2;
76558   {
76559     try {
76560       (arg1)->UnbindActor(arg2);
76561     } catch (std::out_of_range& e) {
76562       {
76563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76564       };
76565     } catch (std::exception& e) {
76566       {
76567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76568       };
76569     } catch (Dali::DaliException e) {
76570       {
76571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76572       };
76573     } catch (...) {
76574       {
76575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76576       };
76577     }
76578   }
76579
76580 }
76581
76582
76583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
76584   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76585   Dali::Radian arg2 ;
76586   Dali::Radian arg3 ;
76587   Dali::Radian *argp2 ;
76588   Dali::Radian *argp3 ;
76589
76590   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76591   argp2 = (Dali::Radian *)jarg2;
76592   if (!argp2) {
76593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76594     return ;
76595   }
76596   arg2 = *argp2;
76597   argp3 = (Dali::Radian *)jarg3;
76598   if (!argp3) {
76599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76600     return ;
76601   }
76602   arg3 = *argp3;
76603   {
76604     try {
76605       (arg1)->SetScrollingDirection(arg2,arg3);
76606     } catch (std::out_of_range& e) {
76607       {
76608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76609       };
76610     } catch (std::exception& e) {
76611       {
76612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76613       };
76614     } catch (Dali::DaliException e) {
76615       {
76616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76617       };
76618     } catch (...) {
76619       {
76620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76621       };
76622     }
76623   }
76624
76625 }
76626
76627
76628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
76629   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76630   Dali::Radian arg2 ;
76631   Dali::Radian *argp2 ;
76632
76633   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76634   argp2 = (Dali::Radian *)jarg2;
76635   if (!argp2) {
76636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76637     return ;
76638   }
76639   arg2 = *argp2;
76640   {
76641     try {
76642       (arg1)->SetScrollingDirection(arg2);
76643     } catch (std::out_of_range& e) {
76644       {
76645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76646       };
76647     } catch (std::exception& e) {
76648       {
76649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76650       };
76651     } catch (Dali::DaliException e) {
76652       {
76653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76654       };
76655     } catch (...) {
76656       {
76657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76658       };
76659     }
76660   }
76661
76662 }
76663
76664
76665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76666   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76667   Dali::Radian arg2 ;
76668   Dali::Radian *argp2 ;
76669
76670   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76671   argp2 = (Dali::Radian *)jarg2;
76672   if (!argp2) {
76673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76674     return ;
76675   }
76676   arg2 = *argp2;
76677   {
76678     try {
76679       (arg1)->RemoveScrollingDirection(arg2);
76680     } catch (std::out_of_range& e) {
76681       {
76682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76683       };
76684     } catch (std::exception& e) {
76685       {
76686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76687       };
76688     } catch (Dali::DaliException e) {
76689       {
76690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76691       };
76692     } catch (...) {
76693       {
76694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76695       };
76696     }
76697   }
76698
76699 }
76700
76701
76702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76703   void * jresult ;
76704   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76705   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76706
76707   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76708   {
76709     try {
76710       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
76711     } catch (std::out_of_range& e) {
76712       {
76713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76714       };
76715     } catch (std::exception& e) {
76716       {
76717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76718       };
76719     } catch (Dali::DaliException e) {
76720       {
76721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76722       };
76723     } catch (...) {
76724       {
76725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76726       };
76727     }
76728   }
76729
76730   jresult = (void *)result;
76731   return jresult;
76732 }
76733
76734
76735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76736   int jresult ;
76737   int result;
76738
76739   result = (int)Dali::Toolkit::TableView::Property::ROWS;
76740   jresult = (int)result;
76741   return jresult;
76742 }
76743
76744
76745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
76746   int jresult ;
76747   int result;
76748
76749   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
76750   jresult = (int)result;
76751   return jresult;
76752 }
76753
76754
76755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
76756   int jresult ;
76757   int result;
76758
76759   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
76760   jresult = (int)result;
76761   return jresult;
76762 }
76763
76764
76765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
76766   int jresult ;
76767   int result;
76768
76769   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
76770   jresult = (int)result;
76771   return jresult;
76772 }
76773
76774
76775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
76776   int jresult ;
76777   int result;
76778
76779   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
76780   jresult = (int)result;
76781   return jresult;
76782 }
76783
76784
76785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
76786   void * jresult ;
76787   Dali::Toolkit::TableView::Property *result = 0 ;
76788
76789   {
76790     try {
76791       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
76792     } catch (std::out_of_range& e) {
76793       {
76794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76795       };
76796     } catch (std::exception& e) {
76797       {
76798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76799       };
76800     } catch (Dali::DaliException e) {
76801       {
76802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76803       };
76804     } catch (...) {
76805       {
76806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76807       };
76808     }
76809   }
76810
76811   jresult = (void *)result;
76812   return jresult;
76813 }
76814
76815
76816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
76817   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
76818
76819   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
76820   {
76821     try {
76822       delete arg1;
76823     } catch (std::out_of_range& e) {
76824       {
76825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76826       };
76827     } catch (std::exception& e) {
76828       {
76829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76830       };
76831     } catch (Dali::DaliException e) {
76832       {
76833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76834       };
76835     } catch (...) {
76836       {
76837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76838       };
76839     }
76840   }
76841
76842 }
76843
76844
76845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
76846   int jresult ;
76847   int result;
76848
76849   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
76850   jresult = (int)result;
76851   return jresult;
76852 }
76853
76854
76855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
76856   int jresult ;
76857   int result;
76858
76859   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
76860   jresult = (int)result;
76861   return jresult;
76862 }
76863
76864
76865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
76866   int jresult ;
76867   int result;
76868
76869   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
76870   jresult = (int)result;
76871   return jresult;
76872 }
76873
76874
76875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
76876   int jresult ;
76877   int result;
76878
76879   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
76880   jresult = (int)result;
76881   return jresult;
76882 }
76883
76884
76885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
76886   int jresult ;
76887   int result;
76888
76889   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
76890   jresult = (int)result;
76891   return jresult;
76892 }
76893
76894
76895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
76896   void * jresult ;
76897   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
76898
76899   {
76900     try {
76901       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
76902     } catch (std::out_of_range& e) {
76903       {
76904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76905       };
76906     } catch (std::exception& e) {
76907       {
76908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76909       };
76910     } catch (Dali::DaliException e) {
76911       {
76912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76913       };
76914     } catch (...) {
76915       {
76916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76917       };
76918     }
76919   }
76920
76921   jresult = (void *)result;
76922   return jresult;
76923 }
76924
76925
76926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
76927   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
76928
76929   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
76930   {
76931     try {
76932       delete arg1;
76933     } catch (std::out_of_range& e) {
76934       {
76935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76936       };
76937     } catch (std::exception& e) {
76938       {
76939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76940       };
76941     } catch (Dali::DaliException e) {
76942       {
76943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76944       };
76945     } catch (...) {
76946       {
76947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76948       };
76949     }
76950   }
76951
76952 }
76953
76954
76955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
76956   void * jresult ;
76957   unsigned int arg1 ;
76958   unsigned int arg2 ;
76959   unsigned int arg3 ;
76960   unsigned int arg4 ;
76961   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76962
76963   arg1 = (unsigned int)jarg1;
76964   arg2 = (unsigned int)jarg2;
76965   arg3 = (unsigned int)jarg3;
76966   arg4 = (unsigned int)jarg4;
76967   {
76968     try {
76969       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
76970     } catch (std::out_of_range& e) {
76971       {
76972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76973       };
76974     } catch (std::exception& e) {
76975       {
76976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76977       };
76978     } catch (Dali::DaliException e) {
76979       {
76980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76981       };
76982     } catch (...) {
76983       {
76984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76985       };
76986     }
76987   }
76988
76989   jresult = (void *)result;
76990   return jresult;
76991 }
76992
76993
76994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
76995   void * jresult ;
76996   unsigned int arg1 ;
76997   unsigned int arg2 ;
76998   unsigned int arg3 ;
76999   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77000
77001   arg1 = (unsigned int)jarg1;
77002   arg2 = (unsigned int)jarg2;
77003   arg3 = (unsigned int)jarg3;
77004   {
77005     try {
77006       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
77007     } catch (std::out_of_range& e) {
77008       {
77009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77010       };
77011     } catch (std::exception& e) {
77012       {
77013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77014       };
77015     } catch (Dali::DaliException e) {
77016       {
77017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77018       };
77019     } catch (...) {
77020       {
77021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77022       };
77023     }
77024   }
77025
77026   jresult = (void *)result;
77027   return jresult;
77028 }
77029
77030
77031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
77032   void * jresult ;
77033   unsigned int arg1 ;
77034   unsigned int arg2 ;
77035   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77036
77037   arg1 = (unsigned int)jarg1;
77038   arg2 = (unsigned int)jarg2;
77039   {
77040     try {
77041       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
77042     } catch (std::out_of_range& e) {
77043       {
77044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77045       };
77046     } catch (std::exception& e) {
77047       {
77048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77049       };
77050     } catch (Dali::DaliException e) {
77051       {
77052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77053       };
77054     } catch (...) {
77055       {
77056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77057       };
77058     }
77059   }
77060
77061   jresult = (void *)result;
77062   return jresult;
77063 }
77064
77065
77066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
77067   void * jresult ;
77068   unsigned int arg1 ;
77069   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77070
77071   arg1 = (unsigned int)jarg1;
77072   {
77073     try {
77074       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
77075     } catch (std::out_of_range& e) {
77076       {
77077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77078       };
77079     } catch (std::exception& e) {
77080       {
77081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77082       };
77083     } catch (Dali::DaliException e) {
77084       {
77085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77086       };
77087     } catch (...) {
77088       {
77089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77090       };
77091     }
77092   }
77093
77094   jresult = (void *)result;
77095   return jresult;
77096 }
77097
77098
77099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
77100   void * jresult ;
77101   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77102
77103   {
77104     try {
77105       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
77106     } catch (std::out_of_range& e) {
77107       {
77108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77109       };
77110     } catch (std::exception& e) {
77111       {
77112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77113       };
77114     } catch (Dali::DaliException e) {
77115       {
77116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77117       };
77118     } catch (...) {
77119       {
77120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77121       };
77122     }
77123   }
77124
77125   jresult = (void *)result;
77126   return jresult;
77127 }
77128
77129
77130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_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)->rowIndex = arg2;
77137 }
77138
77139
77140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_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)->rowIndex);
77147   jresult = result;
77148   return jresult;
77149 }
77150
77151
77152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_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)->columnIndex = arg2;
77159 }
77160
77161
77162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_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)->columnIndex);
77169   jresult = result;
77170   return jresult;
77171 }
77172
77173
77174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_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)->rowSpan = arg2;
77181 }
77182
77183
77184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_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)->rowSpan);
77191   jresult = result;
77192   return jresult;
77193 }
77194
77195
77196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
77197   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77198   unsigned int arg2 ;
77199
77200   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77201   arg2 = (unsigned int)jarg2;
77202   if (arg1) (arg1)->columnSpan = arg2;
77203 }
77204
77205
77206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
77207   unsigned int jresult ;
77208   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77209   unsigned int result;
77210
77211   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77212   result = (unsigned int) ((arg1)->columnSpan);
77213   jresult = result;
77214   return jresult;
77215 }
77216
77217
77218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
77219   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77220
77221   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77222   {
77223     try {
77224       delete arg1;
77225     } catch (std::out_of_range& e) {
77226       {
77227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77228       };
77229     } catch (std::exception& e) {
77230       {
77231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77232       };
77233     } catch (Dali::DaliException e) {
77234       {
77235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77236       };
77237     } catch (...) {
77238       {
77239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77240       };
77241     }
77242   }
77243
77244 }
77245
77246
77247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
77248   void * jresult ;
77249   Dali::Toolkit::TableView *result = 0 ;
77250
77251   {
77252     try {
77253       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
77254     } catch (std::out_of_range& e) {
77255       {
77256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77257       };
77258     } catch (std::exception& e) {
77259       {
77260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77261       };
77262     } catch (Dali::DaliException e) {
77263       {
77264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77265       };
77266     } catch (...) {
77267       {
77268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77269       };
77270     }
77271   }
77272
77273   jresult = (void *)result;
77274   return jresult;
77275 }
77276
77277
77278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
77279   void * jresult ;
77280   Dali::Toolkit::TableView *arg1 = 0 ;
77281   Dali::Toolkit::TableView *result = 0 ;
77282
77283   arg1 = (Dali::Toolkit::TableView *)jarg1;
77284   if (!arg1) {
77285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77286     return 0;
77287   }
77288   {
77289     try {
77290       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
77291     } catch (std::out_of_range& e) {
77292       {
77293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77294       };
77295     } catch (std::exception& e) {
77296       {
77297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77298       };
77299     } catch (Dali::DaliException e) {
77300       {
77301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77302       };
77303     } catch (...) {
77304       {
77305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77306       };
77307     }
77308   }
77309
77310   jresult = (void *)result;
77311   return jresult;
77312 }
77313
77314
77315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
77316   void * jresult ;
77317   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77318   Dali::Toolkit::TableView *arg2 = 0 ;
77319   Dali::Toolkit::TableView *result = 0 ;
77320
77321   arg1 = (Dali::Toolkit::TableView *)jarg1;
77322   arg2 = (Dali::Toolkit::TableView *)jarg2;
77323   if (!arg2) {
77324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77325     return 0;
77326   }
77327   {
77328     try {
77329       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
77330     } catch (std::out_of_range& e) {
77331       {
77332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77333       };
77334     } catch (std::exception& e) {
77335       {
77336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77337       };
77338     } catch (Dali::DaliException e) {
77339       {
77340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77341       };
77342     } catch (...) {
77343       {
77344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77345       };
77346     }
77347   }
77348
77349   jresult = (void *)result;
77350   return jresult;
77351 }
77352
77353
77354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
77355   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77356
77357   arg1 = (Dali::Toolkit::TableView *)jarg1;
77358   {
77359     try {
77360       delete arg1;
77361     } catch (std::out_of_range& e) {
77362       {
77363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77364       };
77365     } catch (std::exception& e) {
77366       {
77367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77368       };
77369     } catch (Dali::DaliException e) {
77370       {
77371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77372       };
77373     } catch (...) {
77374       {
77375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77376       };
77377     }
77378   }
77379
77380 }
77381
77382
77383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
77384   void * jresult ;
77385   unsigned int arg1 ;
77386   unsigned int arg2 ;
77387   Dali::Toolkit::TableView result;
77388
77389   arg1 = (unsigned int)jarg1;
77390   arg2 = (unsigned int)jarg2;
77391   {
77392     try {
77393       result = Dali::Toolkit::TableView::New(arg1,arg2);
77394     } catch (std::out_of_range& e) {
77395       {
77396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77397       };
77398     } catch (std::exception& e) {
77399       {
77400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77401       };
77402     } catch (Dali::DaliException e) {
77403       {
77404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77405       };
77406     } catch (...) {
77407       {
77408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77409       };
77410     }
77411   }
77412
77413   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77414   return jresult;
77415 }
77416
77417
77418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
77419   void * jresult ;
77420   Dali::BaseHandle arg1 ;
77421   Dali::BaseHandle *argp1 ;
77422   Dali::Toolkit::TableView result;
77423
77424   argp1 = (Dali::BaseHandle *)jarg1;
77425   if (!argp1) {
77426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77427     return 0;
77428   }
77429   arg1 = *argp1;
77430   {
77431     try {
77432       result = Dali::Toolkit::TableView::DownCast(arg1);
77433     } catch (std::out_of_range& e) {
77434       {
77435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77436       };
77437     } catch (std::exception& e) {
77438       {
77439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77440       };
77441     } catch (Dali::DaliException e) {
77442       {
77443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77444       };
77445     } catch (...) {
77446       {
77447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77448       };
77449     }
77450   }
77451
77452   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77453   return jresult;
77454 }
77455
77456
77457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
77458   unsigned int jresult ;
77459   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77460   Dali::Actor arg2 ;
77461   Dali::Toolkit::TableView::CellPosition arg3 ;
77462   Dali::Actor *argp2 ;
77463   Dali::Toolkit::TableView::CellPosition *argp3 ;
77464   bool result;
77465
77466   arg1 = (Dali::Toolkit::TableView *)jarg1;
77467   argp2 = (Dali::Actor *)jarg2;
77468   if (!argp2) {
77469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77470     return 0;
77471   }
77472   arg2 = *argp2;
77473   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77474   if (!argp3) {
77475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77476     return 0;
77477   }
77478   arg3 = *argp3;
77479   {
77480     try {
77481       result = (bool)(arg1)->AddChild(arg2,arg3);
77482     } catch (std::out_of_range& e) {
77483       {
77484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77485       };
77486     } catch (std::exception& e) {
77487       {
77488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77489       };
77490     } catch (Dali::DaliException e) {
77491       {
77492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77493       };
77494     } catch (...) {
77495       {
77496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77497       };
77498     }
77499   }
77500
77501   jresult = result;
77502   return jresult;
77503 }
77504
77505
77506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
77507   void * jresult ;
77508   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77509   Dali::Toolkit::TableView::CellPosition arg2 ;
77510   Dali::Toolkit::TableView::CellPosition *argp2 ;
77511   Dali::Actor result;
77512
77513   arg1 = (Dali::Toolkit::TableView *)jarg1;
77514   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77515   if (!argp2) {
77516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77517     return 0;
77518   }
77519   arg2 = *argp2;
77520   {
77521     try {
77522       result = (arg1)->GetChildAt(arg2);
77523     } catch (std::out_of_range& e) {
77524       {
77525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77526       };
77527     } catch (std::exception& e) {
77528       {
77529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77530       };
77531     } catch (Dali::DaliException e) {
77532       {
77533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77534       };
77535     } catch (...) {
77536       {
77537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77538       };
77539     }
77540   }
77541
77542   jresult = new Dali::Actor((const Dali::Actor &)result);
77543   return jresult;
77544 }
77545
77546
77547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
77548   void * jresult ;
77549   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77550   Dali::Toolkit::TableView::CellPosition arg2 ;
77551   Dali::Toolkit::TableView::CellPosition *argp2 ;
77552   Dali::Actor result;
77553
77554   arg1 = (Dali::Toolkit::TableView *)jarg1;
77555   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77556   if (!argp2) {
77557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77558     return 0;
77559   }
77560   arg2 = *argp2;
77561   {
77562     try {
77563       result = (arg1)->RemoveChildAt(arg2);
77564     } catch (std::out_of_range& e) {
77565       {
77566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77567       };
77568     } catch (std::exception& e) {
77569       {
77570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77571       };
77572     } catch (Dali::DaliException e) {
77573       {
77574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77575       };
77576     } catch (...) {
77577       {
77578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77579       };
77580     }
77581   }
77582
77583   jresult = new Dali::Actor((const Dali::Actor &)result);
77584   return jresult;
77585 }
77586
77587
77588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
77589   unsigned int jresult ;
77590   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77591   Dali::Actor arg2 ;
77592   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
77593   Dali::Actor *argp2 ;
77594   bool result;
77595
77596   arg1 = (Dali::Toolkit::TableView *)jarg1;
77597   argp2 = (Dali::Actor *)jarg2;
77598   if (!argp2) {
77599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77600     return 0;
77601   }
77602   arg2 = *argp2;
77603   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77604   if (!arg3) {
77605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
77606     return 0;
77607   }
77608   {
77609     try {
77610       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
77611     } catch (std::out_of_range& e) {
77612       {
77613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77614       };
77615     } catch (std::exception& e) {
77616       {
77617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77618       };
77619     } catch (Dali::DaliException e) {
77620       {
77621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77622       };
77623     } catch (...) {
77624       {
77625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77626       };
77627     }
77628   }
77629
77630   jresult = result;
77631   return jresult;
77632 }
77633
77634
77635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
77636   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77637   unsigned int arg2 ;
77638
77639   arg1 = (Dali::Toolkit::TableView *)jarg1;
77640   arg2 = (unsigned int)jarg2;
77641   {
77642     try {
77643       (arg1)->InsertRow(arg2);
77644     } catch (std::out_of_range& e) {
77645       {
77646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77647       };
77648     } catch (std::exception& e) {
77649       {
77650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77651       };
77652     } catch (Dali::DaliException e) {
77653       {
77654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77655       };
77656     } catch (...) {
77657       {
77658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77659       };
77660     }
77661   }
77662
77663 }
77664
77665
77666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
77667   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77668   unsigned int arg2 ;
77669
77670   arg1 = (Dali::Toolkit::TableView *)jarg1;
77671   arg2 = (unsigned int)jarg2;
77672   {
77673     try {
77674       (arg1)->DeleteRow(arg2);
77675     } catch (std::out_of_range& e) {
77676       {
77677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77678       };
77679     } catch (std::exception& e) {
77680       {
77681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77682       };
77683     } catch (Dali::DaliException e) {
77684       {
77685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77686       };
77687     } catch (...) {
77688       {
77689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77690       };
77691     }
77692   }
77693
77694 }
77695
77696
77697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77698   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77699   unsigned int arg2 ;
77700   std::vector< Dali::Actor > *arg3 = 0 ;
77701
77702   arg1 = (Dali::Toolkit::TableView *)jarg1;
77703   arg2 = (unsigned int)jarg2;
77704   arg3 = (std::vector< Dali::Actor > *)jarg3;
77705   if (!arg3) {
77706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77707     return ;
77708   }
77709   {
77710     try {
77711       (arg1)->DeleteRow(arg2,*arg3);
77712     } catch (std::out_of_range& e) {
77713       {
77714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77715       };
77716     } catch (std::exception& e) {
77717       {
77718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77719       };
77720     } catch (Dali::DaliException e) {
77721       {
77722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77723       };
77724     } catch (...) {
77725       {
77726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77727       };
77728     }
77729   }
77730
77731 }
77732
77733
77734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
77735   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77736   unsigned int arg2 ;
77737
77738   arg1 = (Dali::Toolkit::TableView *)jarg1;
77739   arg2 = (unsigned int)jarg2;
77740   {
77741     try {
77742       (arg1)->InsertColumn(arg2);
77743     } catch (std::out_of_range& e) {
77744       {
77745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77746       };
77747     } catch (std::exception& e) {
77748       {
77749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77750       };
77751     } catch (Dali::DaliException e) {
77752       {
77753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77754       };
77755     } catch (...) {
77756       {
77757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77758       };
77759     }
77760   }
77761
77762 }
77763
77764
77765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
77766   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77767   unsigned int arg2 ;
77768
77769   arg1 = (Dali::Toolkit::TableView *)jarg1;
77770   arg2 = (unsigned int)jarg2;
77771   {
77772     try {
77773       (arg1)->DeleteColumn(arg2);
77774     } catch (std::out_of_range& e) {
77775       {
77776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77777       };
77778     } catch (std::exception& e) {
77779       {
77780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77781       };
77782     } catch (Dali::DaliException e) {
77783       {
77784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77785       };
77786     } catch (...) {
77787       {
77788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77789       };
77790     }
77791   }
77792
77793 }
77794
77795
77796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77797   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77798   unsigned int arg2 ;
77799   std::vector< Dali::Actor > *arg3 = 0 ;
77800
77801   arg1 = (Dali::Toolkit::TableView *)jarg1;
77802   arg2 = (unsigned int)jarg2;
77803   arg3 = (std::vector< Dali::Actor > *)jarg3;
77804   if (!arg3) {
77805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77806     return ;
77807   }
77808   {
77809     try {
77810       (arg1)->DeleteColumn(arg2,*arg3);
77811     } catch (std::out_of_range& e) {
77812       {
77813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77814       };
77815     } catch (std::exception& e) {
77816       {
77817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77818       };
77819     } catch (Dali::DaliException e) {
77820       {
77821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77822       };
77823     } catch (...) {
77824       {
77825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77826       };
77827     }
77828   }
77829
77830 }
77831
77832
77833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
77834   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77835   unsigned int arg2 ;
77836   unsigned int arg3 ;
77837
77838   arg1 = (Dali::Toolkit::TableView *)jarg1;
77839   arg2 = (unsigned int)jarg2;
77840   arg3 = (unsigned int)jarg3;
77841   {
77842     try {
77843       (arg1)->Resize(arg2,arg3);
77844     } catch (std::out_of_range& e) {
77845       {
77846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77847       };
77848     } catch (std::exception& e) {
77849       {
77850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77851       };
77852     } catch (Dali::DaliException e) {
77853       {
77854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77855       };
77856     } catch (...) {
77857       {
77858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77859       };
77860     }
77861   }
77862
77863 }
77864
77865
77866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
77867   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77868   unsigned int arg2 ;
77869   unsigned int arg3 ;
77870   std::vector< Dali::Actor > *arg4 = 0 ;
77871
77872   arg1 = (Dali::Toolkit::TableView *)jarg1;
77873   arg2 = (unsigned int)jarg2;
77874   arg3 = (unsigned int)jarg3;
77875   arg4 = (std::vector< Dali::Actor > *)jarg4;
77876   if (!arg4) {
77877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77878     return ;
77879   }
77880   {
77881     try {
77882       (arg1)->Resize(arg2,arg3,*arg4);
77883     } catch (std::out_of_range& e) {
77884       {
77885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77886       };
77887     } catch (std::exception& e) {
77888       {
77889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77890       };
77891     } catch (Dali::DaliException e) {
77892       {
77893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77894       };
77895     } catch (...) {
77896       {
77897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77898       };
77899     }
77900   }
77901
77902 }
77903
77904
77905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
77906   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77907   Dali::Size arg2 ;
77908   Dali::Size *argp2 ;
77909
77910   arg1 = (Dali::Toolkit::TableView *)jarg1;
77911   argp2 = (Dali::Size *)jarg2;
77912   if (!argp2) {
77913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
77914     return ;
77915   }
77916   arg2 = *argp2;
77917   {
77918     try {
77919       (arg1)->SetCellPadding(arg2);
77920     } catch (std::out_of_range& e) {
77921       {
77922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77923       };
77924     } catch (std::exception& e) {
77925       {
77926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77927       };
77928     } catch (Dali::DaliException e) {
77929       {
77930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77931       };
77932     } catch (...) {
77933       {
77934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77935       };
77936     }
77937   }
77938
77939 }
77940
77941
77942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
77943   void * jresult ;
77944   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77945   Dali::Size result;
77946
77947   arg1 = (Dali::Toolkit::TableView *)jarg1;
77948   {
77949     try {
77950       result = (arg1)->GetCellPadding();
77951     } catch (std::out_of_range& e) {
77952       {
77953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77954       };
77955     } catch (std::exception& e) {
77956       {
77957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77958       };
77959     } catch (Dali::DaliException e) {
77960       {
77961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77962       };
77963     } catch (...) {
77964       {
77965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77966       };
77967     }
77968   }
77969
77970   jresult = new Dali::Size((const Dali::Size &)result);
77971   return jresult;
77972 }
77973
77974
77975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
77976   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77977   unsigned int arg2 ;
77978
77979   arg1 = (Dali::Toolkit::TableView *)jarg1;
77980   arg2 = (unsigned int)jarg2;
77981   {
77982     try {
77983       (arg1)->SetFitHeight(arg2);
77984     } catch (std::out_of_range& e) {
77985       {
77986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77987       };
77988     } catch (std::exception& e) {
77989       {
77990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77991       };
77992     } catch (Dali::DaliException e) {
77993       {
77994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77995       };
77996     } catch (...) {
77997       {
77998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77999       };
78000     }
78001   }
78002
78003 }
78004
78005
78006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
78007   unsigned int jresult ;
78008   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78009   unsigned int arg2 ;
78010   bool result;
78011
78012   arg1 = (Dali::Toolkit::TableView *)jarg1;
78013   arg2 = (unsigned int)jarg2;
78014   {
78015     try {
78016       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
78017     } catch (std::out_of_range& e) {
78018       {
78019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78020       };
78021     } catch (std::exception& e) {
78022       {
78023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78024       };
78025     } catch (Dali::DaliException e) {
78026       {
78027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78028       };
78029     } catch (...) {
78030       {
78031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78032       };
78033     }
78034   }
78035
78036   jresult = result;
78037   return jresult;
78038 }
78039
78040
78041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
78042   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78043   unsigned int arg2 ;
78044
78045   arg1 = (Dali::Toolkit::TableView *)jarg1;
78046   arg2 = (unsigned int)jarg2;
78047   {
78048     try {
78049       (arg1)->SetFitWidth(arg2);
78050     } catch (std::out_of_range& e) {
78051       {
78052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78053       };
78054     } catch (std::exception& e) {
78055       {
78056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78057       };
78058     } catch (Dali::DaliException e) {
78059       {
78060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78061       };
78062     } catch (...) {
78063       {
78064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78065       };
78066     }
78067   }
78068
78069 }
78070
78071
78072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
78073   unsigned int jresult ;
78074   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78075   unsigned int arg2 ;
78076   bool result;
78077
78078   arg1 = (Dali::Toolkit::TableView *)jarg1;
78079   arg2 = (unsigned int)jarg2;
78080   {
78081     try {
78082       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
78083     } catch (std::out_of_range& e) {
78084       {
78085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78086       };
78087     } catch (std::exception& e) {
78088       {
78089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78090       };
78091     } catch (Dali::DaliException e) {
78092       {
78093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78094       };
78095     } catch (...) {
78096       {
78097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78098       };
78099     }
78100   }
78101
78102   jresult = result;
78103   return jresult;
78104 }
78105
78106
78107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78108   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78109   unsigned int arg2 ;
78110   float arg3 ;
78111
78112   arg1 = (Dali::Toolkit::TableView *)jarg1;
78113   arg2 = (unsigned int)jarg2;
78114   arg3 = (float)jarg3;
78115   {
78116     try {
78117       (arg1)->SetFixedHeight(arg2,arg3);
78118     } catch (std::out_of_range& e) {
78119       {
78120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78121       };
78122     } catch (std::exception& e) {
78123       {
78124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78125       };
78126     } catch (Dali::DaliException e) {
78127       {
78128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78129       };
78130     } catch (...) {
78131       {
78132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78133       };
78134     }
78135   }
78136
78137 }
78138
78139
78140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
78141   float jresult ;
78142   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78143   unsigned int arg2 ;
78144   float result;
78145
78146   arg1 = (Dali::Toolkit::TableView *)jarg1;
78147   arg2 = (unsigned int)jarg2;
78148   {
78149     try {
78150       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
78151     } catch (std::out_of_range& e) {
78152       {
78153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78154       };
78155     } catch (std::exception& e) {
78156       {
78157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78158       };
78159     } catch (Dali::DaliException e) {
78160       {
78161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78162       };
78163     } catch (...) {
78164       {
78165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78166       };
78167     }
78168   }
78169
78170   jresult = result;
78171   return jresult;
78172 }
78173
78174
78175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78176   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78177   unsigned int arg2 ;
78178   float arg3 ;
78179
78180   arg1 = (Dali::Toolkit::TableView *)jarg1;
78181   arg2 = (unsigned int)jarg2;
78182   arg3 = (float)jarg3;
78183   {
78184     try {
78185       (arg1)->SetRelativeHeight(arg2,arg3);
78186     } catch (std::out_of_range& e) {
78187       {
78188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78189       };
78190     } catch (std::exception& e) {
78191       {
78192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78193       };
78194     } catch (Dali::DaliException e) {
78195       {
78196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78197       };
78198     } catch (...) {
78199       {
78200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78201       };
78202     }
78203   }
78204
78205 }
78206
78207
78208 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
78209   float jresult ;
78210   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78211   unsigned int arg2 ;
78212   float result;
78213
78214   arg1 = (Dali::Toolkit::TableView *)jarg1;
78215   arg2 = (unsigned int)jarg2;
78216   {
78217     try {
78218       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
78219     } catch (std::out_of_range& e) {
78220       {
78221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78222       };
78223     } catch (std::exception& e) {
78224       {
78225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78226       };
78227     } catch (Dali::DaliException e) {
78228       {
78229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78230       };
78231     } catch (...) {
78232       {
78233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78234       };
78235     }
78236   }
78237
78238   jresult = result;
78239   return jresult;
78240 }
78241
78242
78243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78244   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78245   unsigned int arg2 ;
78246   float arg3 ;
78247
78248   arg1 = (Dali::Toolkit::TableView *)jarg1;
78249   arg2 = (unsigned int)jarg2;
78250   arg3 = (float)jarg3;
78251   {
78252     try {
78253       (arg1)->SetFixedWidth(arg2,arg3);
78254     } catch (std::out_of_range& e) {
78255       {
78256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78257       };
78258     } catch (std::exception& e) {
78259       {
78260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78261       };
78262     } catch (Dali::DaliException e) {
78263       {
78264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78265       };
78266     } catch (...) {
78267       {
78268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78269       };
78270     }
78271   }
78272
78273 }
78274
78275
78276 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
78277   float jresult ;
78278   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78279   unsigned int arg2 ;
78280   float result;
78281
78282   arg1 = (Dali::Toolkit::TableView *)jarg1;
78283   arg2 = (unsigned int)jarg2;
78284   {
78285     try {
78286       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
78287     } catch (std::out_of_range& e) {
78288       {
78289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78290       };
78291     } catch (std::exception& e) {
78292       {
78293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78294       };
78295     } catch (Dali::DaliException e) {
78296       {
78297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78298       };
78299     } catch (...) {
78300       {
78301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78302       };
78303     }
78304   }
78305
78306   jresult = result;
78307   return jresult;
78308 }
78309
78310
78311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78312   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78313   unsigned int arg2 ;
78314   float arg3 ;
78315
78316   arg1 = (Dali::Toolkit::TableView *)jarg1;
78317   arg2 = (unsigned int)jarg2;
78318   arg3 = (float)jarg3;
78319   {
78320     try {
78321       (arg1)->SetRelativeWidth(arg2,arg3);
78322     } catch (std::out_of_range& e) {
78323       {
78324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78325       };
78326     } catch (std::exception& e) {
78327       {
78328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78329       };
78330     } catch (Dali::DaliException e) {
78331       {
78332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78333       };
78334     } catch (...) {
78335       {
78336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78337       };
78338     }
78339   }
78340
78341 }
78342
78343
78344 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
78345   float jresult ;
78346   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78347   unsigned int arg2 ;
78348   float result;
78349
78350   arg1 = (Dali::Toolkit::TableView *)jarg1;
78351   arg2 = (unsigned int)jarg2;
78352   {
78353     try {
78354       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
78355     } catch (std::out_of_range& e) {
78356       {
78357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78358       };
78359     } catch (std::exception& e) {
78360       {
78361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78362       };
78363     } catch (Dali::DaliException e) {
78364       {
78365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78366       };
78367     } catch (...) {
78368       {
78369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78370       };
78371     }
78372   }
78373
78374   jresult = result;
78375   return jresult;
78376 }
78377
78378
78379 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
78380   unsigned int jresult ;
78381   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78382   unsigned int result;
78383
78384   arg1 = (Dali::Toolkit::TableView *)jarg1;
78385   {
78386     try {
78387       result = (unsigned int)(arg1)->GetRows();
78388     } catch (std::out_of_range& e) {
78389       {
78390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78391       };
78392     } catch (std::exception& e) {
78393       {
78394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78395       };
78396     } catch (Dali::DaliException e) {
78397       {
78398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78399       };
78400     } catch (...) {
78401       {
78402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78403       };
78404     }
78405   }
78406
78407   jresult = result;
78408   return jresult;
78409 }
78410
78411
78412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
78413   unsigned int jresult ;
78414   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78415   unsigned int result;
78416
78417   arg1 = (Dali::Toolkit::TableView *)jarg1;
78418   {
78419     try {
78420       result = (unsigned int)(arg1)->GetColumns();
78421     } catch (std::out_of_range& e) {
78422       {
78423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78424       };
78425     } catch (std::exception& e) {
78426       {
78427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78428       };
78429     } catch (Dali::DaliException e) {
78430       {
78431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78432       };
78433     } catch (...) {
78434       {
78435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78436       };
78437     }
78438   }
78439
78440   jresult = result;
78441   return jresult;
78442 }
78443
78444
78445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
78446   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78447   Dali::Toolkit::TableView::CellPosition arg2 ;
78448   Dali::HorizontalAlignment::Type arg3 ;
78449   Dali::VerticalAlignment::Type arg4 ;
78450   Dali::Toolkit::TableView::CellPosition *argp2 ;
78451
78452   arg1 = (Dali::Toolkit::TableView *)jarg1;
78453   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
78454   if (!argp2) {
78455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
78456     return ;
78457   }
78458   arg2 = *argp2;
78459   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
78460   arg4 = (Dali::VerticalAlignment::Type)jarg4;
78461   {
78462     try {
78463       (arg1)->SetCellAlignment(arg2,arg3,arg4);
78464     } catch (std::out_of_range& e) {
78465       {
78466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78467       };
78468     } catch (std::exception& e) {
78469       {
78470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78471       };
78472     } catch (Dali::DaliException e) {
78473       {
78474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78475       };
78476     } catch (...) {
78477       {
78478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78479       };
78480     }
78481   }
78482
78483 }
78484
78485
78486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
78487   unsigned int jresult ;
78488   unsigned int result;
78489
78490   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
78491   jresult = result;
78492   return jresult;
78493 }
78494
78495
78496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78497   int jresult ;
78498   int result;
78499
78500   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78501   jresult = (int)result;
78502   return jresult;
78503 }
78504
78505
78506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78507   int jresult ;
78508   int result;
78509
78510   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78511   jresult = (int)result;
78512   return jresult;
78513 }
78514
78515
78516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78517   int jresult ;
78518   int result;
78519
78520   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78521   jresult = (int)result;
78522   return jresult;
78523 }
78524
78525
78526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78527   int jresult ;
78528   int result;
78529
78530   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78531   jresult = (int)result;
78532   return jresult;
78533 }
78534
78535
78536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78537   int jresult ;
78538   int result;
78539
78540   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78541   jresult = (int)result;
78542   return jresult;
78543 }
78544
78545
78546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78547   int jresult ;
78548   int result;
78549
78550   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78551   jresult = (int)result;
78552   return jresult;
78553 }
78554
78555
78556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78557   int jresult ;
78558   int result;
78559
78560   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78561   jresult = (int)result;
78562   return jresult;
78563 }
78564
78565
78566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78567   int jresult ;
78568   int result;
78569
78570   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78571   jresult = (int)result;
78572   return jresult;
78573 }
78574
78575
78576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78577   int jresult ;
78578   int result;
78579
78580   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78581   jresult = (int)result;
78582   return jresult;
78583 }
78584
78585
78586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78587   int jresult ;
78588   int result;
78589
78590   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78591   jresult = (int)result;
78592   return jresult;
78593 }
78594
78595
78596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78597   int jresult ;
78598   int result;
78599
78600   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78601   jresult = (int)result;
78602   return jresult;
78603 }
78604
78605
78606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78607   int jresult ;
78608   int result;
78609
78610   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78611   jresult = (int)result;
78612   return jresult;
78613 }
78614
78615
78616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78617   int jresult ;
78618   int result;
78619
78620   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78621   jresult = (int)result;
78622   return jresult;
78623 }
78624
78625
78626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78627   int jresult ;
78628   int result;
78629
78630   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78631   jresult = (int)result;
78632   return jresult;
78633 }
78634
78635
78636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78637   int jresult ;
78638   int result;
78639
78640   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78641   jresult = (int)result;
78642   return jresult;
78643 }
78644
78645
78646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78647   int jresult ;
78648   int result;
78649
78650   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78651   jresult = (int)result;
78652   return jresult;
78653 }
78654
78655
78656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78657   int jresult ;
78658   int result;
78659
78660   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78661   jresult = (int)result;
78662   return jresult;
78663 }
78664
78665
78666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78667   int jresult ;
78668   int result;
78669
78670   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78671   jresult = (int)result;
78672   return jresult;
78673 }
78674
78675
78676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78677   void * jresult ;
78678   Dali::Toolkit::TextLabel::Property *result = 0 ;
78679
78680   {
78681     try {
78682       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78683     } catch (std::out_of_range& e) {
78684       {
78685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78686       };
78687     } catch (std::exception& e) {
78688       {
78689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78690       };
78691     } catch (Dali::DaliException e) {
78692       {
78693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78694       };
78695     } catch (...) {
78696       {
78697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78698       };
78699     }
78700   }
78701
78702   jresult = (void *)result;
78703   return jresult;
78704 }
78705
78706
78707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78708   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78709
78710   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78711   {
78712     try {
78713       delete arg1;
78714     } catch (std::out_of_range& e) {
78715       {
78716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78717       };
78718     } catch (std::exception& e) {
78719       {
78720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78721       };
78722     } catch (Dali::DaliException e) {
78723       {
78724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78725       };
78726     } catch (...) {
78727       {
78728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78729       };
78730     }
78731   }
78732
78733 }
78734
78735
78736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78737   void * jresult ;
78738   Dali::Toolkit::TextLabel result;
78739
78740   {
78741     try {
78742       result = Dali::Toolkit::TextLabel::New();
78743     } catch (std::out_of_range& e) {
78744       {
78745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78746       };
78747     } catch (std::exception& e) {
78748       {
78749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78750       };
78751     } catch (Dali::DaliException e) {
78752       {
78753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78754       };
78755     } catch (...) {
78756       {
78757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78758       };
78759     }
78760   }
78761
78762   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78763   return jresult;
78764 }
78765
78766
78767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78768   void * jresult ;
78769   std::string *arg1 = 0 ;
78770   Dali::Toolkit::TextLabel result;
78771
78772   if (!jarg1) {
78773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78774     return 0;
78775   }
78776   std::string arg1_str(jarg1);
78777   arg1 = &arg1_str;
78778   {
78779     try {
78780       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
78781     } catch (std::out_of_range& e) {
78782       {
78783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78784       };
78785     } catch (std::exception& e) {
78786       {
78787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78788       };
78789     } catch (Dali::DaliException e) {
78790       {
78791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78792       };
78793     } catch (...) {
78794       {
78795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78796       };
78797     }
78798   }
78799
78800   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78801
78802   //argout typemap for const std::string&
78803
78804   return jresult;
78805 }
78806
78807
78808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78809   void * jresult ;
78810   Dali::Toolkit::TextLabel *result = 0 ;
78811
78812   {
78813     try {
78814       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78815     } catch (std::out_of_range& e) {
78816       {
78817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78818       };
78819     } catch (std::exception& e) {
78820       {
78821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78822       };
78823     } catch (Dali::DaliException e) {
78824       {
78825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78826       };
78827     } catch (...) {
78828       {
78829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78830       };
78831     }
78832   }
78833
78834   jresult = (void *)result;
78835   return jresult;
78836 }
78837
78838
78839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78840   void * jresult ;
78841   Dali::Toolkit::TextLabel *arg1 = 0 ;
78842   Dali::Toolkit::TextLabel *result = 0 ;
78843
78844   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78845   if (!arg1) {
78846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78847     return 0;
78848   }
78849   {
78850     try {
78851       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78852     } catch (std::out_of_range& e) {
78853       {
78854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78855       };
78856     } catch (std::exception& e) {
78857       {
78858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78859       };
78860     } catch (Dali::DaliException e) {
78861       {
78862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78863       };
78864     } catch (...) {
78865       {
78866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78867       };
78868     }
78869   }
78870
78871   jresult = (void *)result;
78872   return jresult;
78873 }
78874
78875
78876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78877   void * jresult ;
78878   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78879   Dali::Toolkit::TextLabel *arg2 = 0 ;
78880   Dali::Toolkit::TextLabel *result = 0 ;
78881
78882   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78883   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78884   if (!arg2) {
78885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78886     return 0;
78887   }
78888   {
78889     try {
78890       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
78891     } catch (std::out_of_range& e) {
78892       {
78893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78894       };
78895     } catch (std::exception& e) {
78896       {
78897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78898       };
78899     } catch (Dali::DaliException e) {
78900       {
78901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78902       };
78903     } catch (...) {
78904       {
78905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78906       };
78907     }
78908   }
78909
78910   jresult = (void *)result;
78911   return jresult;
78912 }
78913
78914
78915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
78916   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78917
78918   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78919   {
78920     try {
78921       delete arg1;
78922     } catch (std::out_of_range& e) {
78923       {
78924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78925       };
78926     } catch (std::exception& e) {
78927       {
78928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78929       };
78930     } catch (Dali::DaliException e) {
78931       {
78932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78933       };
78934     } catch (...) {
78935       {
78936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78937       };
78938     }
78939   }
78940
78941 }
78942
78943
78944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
78945   void * jresult ;
78946   Dali::BaseHandle arg1 ;
78947   Dali::BaseHandle *argp1 ;
78948   Dali::Toolkit::TextLabel result;
78949
78950   argp1 = (Dali::BaseHandle *)jarg1;
78951   if (!argp1) {
78952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78953     return 0;
78954   }
78955   arg1 = *argp1;
78956   {
78957     try {
78958       result = Dali::Toolkit::TextLabel::DownCast(arg1);
78959     } catch (std::out_of_range& e) {
78960       {
78961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78962       };
78963     } catch (std::exception& e) {
78964       {
78965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78966       };
78967     } catch (Dali::DaliException e) {
78968       {
78969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78970       };
78971     } catch (...) {
78972       {
78973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78974       };
78975     }
78976   }
78977
78978   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78979   return jresult;
78980 }
78981
78982
78983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
78984   void * jresult ;
78985   Dali::Toolkit::AccessibilityManager *result = 0 ;
78986
78987   {
78988     try {
78989       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
78990     } catch (std::out_of_range& e) {
78991       {
78992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78993       };
78994     } catch (std::exception& e) {
78995       {
78996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78997       };
78998     } catch (Dali::DaliException e) {
78999       {
79000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79001       };
79002     } catch (...) {
79003       {
79004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79005       };
79006     }
79007   }
79008
79009   jresult = (void *)result;
79010   return jresult;
79011 }
79012
79013
79014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
79015   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79016
79017   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79018   {
79019     try {
79020       delete arg1;
79021     } catch (std::out_of_range& e) {
79022       {
79023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79024       };
79025     } catch (std::exception& e) {
79026       {
79027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79028       };
79029     } catch (Dali::DaliException e) {
79030       {
79031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79032       };
79033     } catch (...) {
79034       {
79035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79036       };
79037     }
79038   }
79039
79040 }
79041
79042
79043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
79044   void * jresult ;
79045   Dali::Toolkit::AccessibilityManager result;
79046
79047   {
79048     try {
79049       result = Dali::Toolkit::AccessibilityManager::Get();
79050     } catch (std::out_of_range& e) {
79051       {
79052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79053       };
79054     } catch (std::exception& e) {
79055       {
79056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79057       };
79058     } catch (Dali::DaliException e) {
79059       {
79060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79061       };
79062     } catch (...) {
79063       {
79064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79065       };
79066     }
79067   }
79068
79069   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79070   return jresult;
79071 }
79072
79073
79074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79075   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79076   Dali::Actor arg2 ;
79077   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79078   std::string *arg4 = 0 ;
79079   Dali::Actor *argp2 ;
79080
79081   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79082   argp2 = (Dali::Actor *)jarg2;
79083   if (!argp2) {
79084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79085     return ;
79086   }
79087   arg2 = *argp2;
79088   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79089   if (!jarg4) {
79090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79091     return ;
79092   }
79093   std::string arg4_str(jarg4);
79094   arg4 = &arg4_str;
79095   {
79096     try {
79097       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79098     } catch (std::out_of_range& e) {
79099       {
79100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79101       };
79102     } catch (std::exception& e) {
79103       {
79104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79105       };
79106     } catch (Dali::DaliException e) {
79107       {
79108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79109       };
79110     } catch (...) {
79111       {
79112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79113       };
79114     }
79115   }
79116
79117
79118   //argout typemap for const std::string&
79119
79120 }
79121
79122
79123 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79124   char * jresult ;
79125   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79126   Dali::Actor arg2 ;
79127   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79128   Dali::Actor *argp2 ;
79129   std::string result;
79130
79131   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79132   argp2 = (Dali::Actor *)jarg2;
79133   if (!argp2) {
79134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79135     return 0;
79136   }
79137   arg2 = *argp2;
79138   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79139   {
79140     try {
79141       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79142     } catch (std::out_of_range& e) {
79143       {
79144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79145       };
79146     } catch (std::exception& e) {
79147       {
79148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79149       };
79150     } catch (Dali::DaliException e) {
79151       {
79152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79153       };
79154     } catch (...) {
79155       {
79156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79157       };
79158     }
79159   }
79160
79161   jresult = SWIG_csharp_string_callback((&result)->c_str());
79162   return jresult;
79163 }
79164
79165
79166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79167   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79168   Dali::Actor arg2 ;
79169   unsigned int arg3 ;
79170   Dali::Actor *argp2 ;
79171
79172   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79173   argp2 = (Dali::Actor *)jarg2;
79174   if (!argp2) {
79175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79176     return ;
79177   }
79178   arg2 = *argp2;
79179   arg3 = (unsigned int)jarg3;
79180   {
79181     try {
79182       (arg1)->SetFocusOrder(arg2,arg3);
79183     } catch (std::out_of_range& e) {
79184       {
79185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79186       };
79187     } catch (std::exception& e) {
79188       {
79189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79190       };
79191     } catch (Dali::DaliException e) {
79192       {
79193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79194       };
79195     } catch (...) {
79196       {
79197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79198       };
79199     }
79200   }
79201
79202 }
79203
79204
79205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79206   unsigned int jresult ;
79207   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79208   Dali::Actor arg2 ;
79209   Dali::Actor *argp2 ;
79210   unsigned int result;
79211
79212   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79213   argp2 = (Dali::Actor *)jarg2;
79214   if (!argp2) {
79215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79216     return 0;
79217   }
79218   arg2 = *argp2;
79219   {
79220     try {
79221       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79222     } catch (std::out_of_range& e) {
79223       {
79224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79225       };
79226     } catch (std::exception& e) {
79227       {
79228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79229       };
79230     } catch (Dali::DaliException e) {
79231       {
79232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79233       };
79234     } catch (...) {
79235       {
79236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79237       };
79238     }
79239   }
79240
79241   jresult = result;
79242   return jresult;
79243 }
79244
79245
79246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79247   unsigned int jresult ;
79248   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79249   unsigned int result;
79250
79251   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79252   {
79253     try {
79254       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79255     } catch (std::out_of_range& e) {
79256       {
79257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79258       };
79259     } catch (std::exception& e) {
79260       {
79261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79262       };
79263     } catch (Dali::DaliException e) {
79264       {
79265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79266       };
79267     } catch (...) {
79268       {
79269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79270       };
79271     }
79272   }
79273
79274   jresult = result;
79275   return jresult;
79276 }
79277
79278
79279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79280   void * jresult ;
79281   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79282   unsigned int arg2 ;
79283   Dali::Actor result;
79284
79285   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79286   arg2 = (unsigned int)jarg2;
79287   {
79288     try {
79289       result = (arg1)->GetActorByFocusOrder(arg2);
79290     } catch (std::out_of_range& e) {
79291       {
79292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79293       };
79294     } catch (std::exception& e) {
79295       {
79296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79297       };
79298     } catch (Dali::DaliException e) {
79299       {
79300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79301       };
79302     } catch (...) {
79303       {
79304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79305       };
79306     }
79307   }
79308
79309   jresult = new Dali::Actor((const Dali::Actor &)result);
79310   return jresult;
79311 }
79312
79313
79314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79315   unsigned int jresult ;
79316   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79317   Dali::Actor arg2 ;
79318   Dali::Actor *argp2 ;
79319   bool result;
79320
79321   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79322   argp2 = (Dali::Actor *)jarg2;
79323   if (!argp2) {
79324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79325     return 0;
79326   }
79327   arg2 = *argp2;
79328   {
79329     try {
79330       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79331     } catch (std::out_of_range& e) {
79332       {
79333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79334       };
79335     } catch (std::exception& e) {
79336       {
79337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79338       };
79339     } catch (Dali::DaliException e) {
79340       {
79341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79342       };
79343     } catch (...) {
79344       {
79345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79346       };
79347     }
79348   }
79349
79350   jresult = result;
79351   return jresult;
79352 }
79353
79354
79355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79356   void * jresult ;
79357   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79358   Dali::Actor result;
79359
79360   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79361   {
79362     try {
79363       result = (arg1)->GetCurrentFocusActor();
79364     } catch (std::out_of_range& e) {
79365       {
79366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79367       };
79368     } catch (std::exception& e) {
79369       {
79370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79371       };
79372     } catch (Dali::DaliException e) {
79373       {
79374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79375       };
79376     } catch (...) {
79377       {
79378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79379       };
79380     }
79381   }
79382
79383   jresult = new Dali::Actor((const Dali::Actor &)result);
79384   return jresult;
79385 }
79386
79387
79388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79389   void * jresult ;
79390   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79391   Dali::Actor result;
79392
79393   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79394   {
79395     try {
79396       result = (arg1)->GetCurrentFocusGroup();
79397     } catch (std::out_of_range& e) {
79398       {
79399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79400       };
79401     } catch (std::exception& e) {
79402       {
79403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79404       };
79405     } catch (Dali::DaliException e) {
79406       {
79407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79408       };
79409     } catch (...) {
79410       {
79411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79412       };
79413     }
79414   }
79415
79416   jresult = new Dali::Actor((const Dali::Actor &)result);
79417   return jresult;
79418 }
79419
79420
79421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79422   unsigned int jresult ;
79423   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79424   unsigned int result;
79425
79426   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79427   {
79428     try {
79429       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79430     } catch (std::out_of_range& e) {
79431       {
79432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79433       };
79434     } catch (std::exception& e) {
79435       {
79436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79437       };
79438     } catch (Dali::DaliException e) {
79439       {
79440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79441       };
79442     } catch (...) {
79443       {
79444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79445       };
79446     }
79447   }
79448
79449   jresult = result;
79450   return jresult;
79451 }
79452
79453
79454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79455   unsigned int jresult ;
79456   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79457   bool result;
79458
79459   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79460   {
79461     try {
79462       result = (bool)(arg1)->MoveFocusForward();
79463     } catch (std::out_of_range& e) {
79464       {
79465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79466       };
79467     } catch (std::exception& e) {
79468       {
79469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79470       };
79471     } catch (Dali::DaliException e) {
79472       {
79473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79474       };
79475     } catch (...) {
79476       {
79477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79478       };
79479     }
79480   }
79481
79482   jresult = result;
79483   return jresult;
79484 }
79485
79486
79487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79488   unsigned int jresult ;
79489   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79490   bool result;
79491
79492   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79493   {
79494     try {
79495       result = (bool)(arg1)->MoveFocusBackward();
79496     } catch (std::out_of_range& e) {
79497       {
79498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79499       };
79500     } catch (std::exception& e) {
79501       {
79502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79503       };
79504     } catch (Dali::DaliException e) {
79505       {
79506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79507       };
79508     } catch (...) {
79509       {
79510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79511       };
79512     }
79513   }
79514
79515   jresult = result;
79516   return jresult;
79517 }
79518
79519
79520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79521   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79522
79523   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79524   {
79525     try {
79526       (arg1)->ClearFocus();
79527     } catch (std::out_of_range& e) {
79528       {
79529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79530       };
79531     } catch (std::exception& e) {
79532       {
79533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79534       };
79535     } catch (Dali::DaliException e) {
79536       {
79537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79538       };
79539     } catch (...) {
79540       {
79541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79542       };
79543     }
79544   }
79545
79546 }
79547
79548
79549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79550   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79551
79552   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79553   {
79554     try {
79555       (arg1)->Reset();
79556     } catch (std::out_of_range& e) {
79557       {
79558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79559       };
79560     } catch (std::exception& e) {
79561       {
79562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79563       };
79564     } catch (Dali::DaliException e) {
79565       {
79566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79567       };
79568     } catch (...) {
79569       {
79570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79571       };
79572     }
79573   }
79574
79575 }
79576
79577
79578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79579   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79580   Dali::Actor arg2 ;
79581   bool arg3 ;
79582   Dali::Actor *argp2 ;
79583
79584   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79585   argp2 = (Dali::Actor *)jarg2;
79586   if (!argp2) {
79587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79588     return ;
79589   }
79590   arg2 = *argp2;
79591   arg3 = jarg3 ? true : false;
79592   {
79593     try {
79594       (arg1)->SetFocusGroup(arg2,arg3);
79595     } catch (std::out_of_range& e) {
79596       {
79597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79598       };
79599     } catch (std::exception& e) {
79600       {
79601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79602       };
79603     } catch (Dali::DaliException e) {
79604       {
79605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79606       };
79607     } catch (...) {
79608       {
79609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79610       };
79611     }
79612   }
79613
79614 }
79615
79616
79617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79618   unsigned int jresult ;
79619   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79620   Dali::Actor arg2 ;
79621   Dali::Actor *argp2 ;
79622   bool result;
79623
79624   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79625   argp2 = (Dali::Actor *)jarg2;
79626   if (!argp2) {
79627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79628     return 0;
79629   }
79630   arg2 = *argp2;
79631   {
79632     try {
79633       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79634     } catch (std::out_of_range& e) {
79635       {
79636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79637       };
79638     } catch (std::exception& e) {
79639       {
79640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79641       };
79642     } catch (Dali::DaliException e) {
79643       {
79644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79645       };
79646     } catch (...) {
79647       {
79648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79649       };
79650     }
79651   }
79652
79653   jresult = result;
79654   return jresult;
79655 }
79656
79657
79658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79659   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79660   bool arg2 ;
79661
79662   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79663   arg2 = jarg2 ? true : false;
79664   {
79665     try {
79666       (arg1)->SetGroupMode(arg2);
79667     } catch (std::out_of_range& e) {
79668       {
79669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79670       };
79671     } catch (std::exception& e) {
79672       {
79673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79674       };
79675     } catch (Dali::DaliException e) {
79676       {
79677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79678       };
79679     } catch (...) {
79680       {
79681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79682       };
79683     }
79684   }
79685
79686 }
79687
79688
79689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79690   unsigned int jresult ;
79691   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79692   bool result;
79693
79694   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79695   {
79696     try {
79697       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79698     } catch (std::out_of_range& e) {
79699       {
79700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79701       };
79702     } catch (std::exception& e) {
79703       {
79704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79705       };
79706     } catch (Dali::DaliException e) {
79707       {
79708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79709       };
79710     } catch (...) {
79711       {
79712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79713       };
79714     }
79715   }
79716
79717   jresult = result;
79718   return jresult;
79719 }
79720
79721
79722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79723   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79724   bool arg2 ;
79725
79726   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79727   arg2 = jarg2 ? true : false;
79728   {
79729     try {
79730       (arg1)->SetWrapMode(arg2);
79731     } catch (std::out_of_range& e) {
79732       {
79733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79734       };
79735     } catch (std::exception& e) {
79736       {
79737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79738       };
79739     } catch (Dali::DaliException e) {
79740       {
79741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79742       };
79743     } catch (...) {
79744       {
79745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79746       };
79747     }
79748   }
79749
79750 }
79751
79752
79753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
79754   unsigned int jresult ;
79755   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79756   bool result;
79757
79758   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79759   {
79760     try {
79761       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
79762     } catch (std::out_of_range& e) {
79763       {
79764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79765       };
79766     } catch (std::exception& e) {
79767       {
79768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79769       };
79770     } catch (Dali::DaliException e) {
79771       {
79772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79773       };
79774     } catch (...) {
79775       {
79776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79777       };
79778     }
79779   }
79780
79781   jresult = result;
79782   return jresult;
79783 }
79784
79785
79786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
79787   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79788   Dali::Actor arg2 ;
79789   Dali::Actor *argp2 ;
79790
79791   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79792   argp2 = (Dali::Actor *)jarg2;
79793   if (!argp2) {
79794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79795     return ;
79796   }
79797   arg2 = *argp2;
79798   {
79799     try {
79800       (arg1)->SetFocusIndicatorActor(arg2);
79801     } catch (std::out_of_range& e) {
79802       {
79803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79804       };
79805     } catch (std::exception& e) {
79806       {
79807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79808       };
79809     } catch (Dali::DaliException e) {
79810       {
79811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79812       };
79813     } catch (...) {
79814       {
79815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79816       };
79817     }
79818   }
79819
79820 }
79821
79822
79823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
79824   void * jresult ;
79825   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79826   Dali::Actor result;
79827
79828   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79829   {
79830     try {
79831       result = (arg1)->GetFocusIndicatorActor();
79832     } catch (std::out_of_range& e) {
79833       {
79834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79835       };
79836     } catch (std::exception& e) {
79837       {
79838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79839       };
79840     } catch (Dali::DaliException e) {
79841       {
79842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79843       };
79844     } catch (...) {
79845       {
79846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79847       };
79848     }
79849   }
79850
79851   jresult = new Dali::Actor((const Dali::Actor &)result);
79852   return jresult;
79853 }
79854
79855
79856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
79857   void * jresult ;
79858   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79859   Dali::Actor arg2 ;
79860   Dali::Actor *argp2 ;
79861   Dali::Actor result;
79862
79863   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79864   argp2 = (Dali::Actor *)jarg2;
79865   if (!argp2) {
79866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79867     return 0;
79868   }
79869   arg2 = *argp2;
79870   {
79871     try {
79872       result = (arg1)->GetFocusGroup(arg2);
79873     } catch (std::out_of_range& e) {
79874       {
79875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79876       };
79877     } catch (std::exception& e) {
79878       {
79879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79880       };
79881     } catch (Dali::DaliException e) {
79882       {
79883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79884       };
79885     } catch (...) {
79886       {
79887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79888       };
79889     }
79890   }
79891
79892   jresult = new Dali::Actor((const Dali::Actor &)result);
79893   return jresult;
79894 }
79895
79896
79897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79898   void * jresult ;
79899   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79900   Dali::Vector2 result;
79901
79902   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79903   {
79904     try {
79905       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79906     } catch (std::out_of_range& e) {
79907       {
79908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79909       };
79910     } catch (std::exception& e) {
79911       {
79912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79913       };
79914     } catch (Dali::DaliException e) {
79915       {
79916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79917       };
79918     } catch (...) {
79919       {
79920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79921       };
79922     }
79923   }
79924
79925   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79926   return jresult;
79927 }
79928
79929
79930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
79931   void * jresult ;
79932   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79933   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
79934
79935   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79936   {
79937     try {
79938       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
79939     } catch (std::out_of_range& e) {
79940       {
79941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79942       };
79943     } catch (std::exception& e) {
79944       {
79945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79946       };
79947     } catch (Dali::DaliException e) {
79948       {
79949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79950       };
79951     } catch (...) {
79952       {
79953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79954       };
79955     }
79956   }
79957
79958   jresult = (void *)result;
79959   return jresult;
79960 }
79961
79962
79963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
79964   void * jresult ;
79965   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79966   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
79967
79968   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79969   {
79970     try {
79971       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
79972     } catch (std::out_of_range& e) {
79973       {
79974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79975       };
79976     } catch (std::exception& e) {
79977       {
79978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79979       };
79980     } catch (Dali::DaliException e) {
79981       {
79982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79983       };
79984     } catch (...) {
79985       {
79986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79987       };
79988     }
79989   }
79990
79991   jresult = (void *)result;
79992   return jresult;
79993 }
79994
79995
79996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
79997   void * jresult ;
79998   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79999   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
80000
80001   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80002   {
80003     try {
80004       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
80005     } catch (std::out_of_range& e) {
80006       {
80007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80008       };
80009     } catch (std::exception& e) {
80010       {
80011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80012       };
80013     } catch (Dali::DaliException e) {
80014       {
80015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80016       };
80017     } catch (...) {
80018       {
80019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80020       };
80021     }
80022   }
80023
80024   jresult = (void *)result;
80025   return jresult;
80026 }
80027
80028
80029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
80030   void * jresult ;
80031   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80032   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80033
80034   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80035   {
80036     try {
80037       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
80038     } catch (std::out_of_range& e) {
80039       {
80040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80041       };
80042     } catch (std::exception& e) {
80043       {
80044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80045       };
80046     } catch (Dali::DaliException e) {
80047       {
80048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80049       };
80050     } catch (...) {
80051       {
80052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80053       };
80054     }
80055   }
80056
80057   jresult = (void *)result;
80058   return jresult;
80059 }
80060
80061
80062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
80063   void * jresult ;
80064   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80065   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80066
80067   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80068   {
80069     try {
80070       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80071     } catch (std::out_of_range& e) {
80072       {
80073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80074       };
80075     } catch (std::exception& e) {
80076       {
80077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80078       };
80079     } catch (Dali::DaliException e) {
80080       {
80081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80082       };
80083     } catch (...) {
80084       {
80085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80086       };
80087     }
80088   }
80089
80090   jresult = (void *)result;
80091   return jresult;
80092 }
80093
80094
80095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80096   void * jresult ;
80097   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80098   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80099
80100   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80101   {
80102     try {
80103       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80104     } catch (std::out_of_range& e) {
80105       {
80106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80107       };
80108     } catch (std::exception& e) {
80109       {
80110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80111       };
80112     } catch (Dali::DaliException e) {
80113       {
80114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80115       };
80116     } catch (...) {
80117       {
80118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80119       };
80120     }
80121   }
80122
80123   jresult = (void *)result;
80124   return jresult;
80125 }
80126
80127
80128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80129   void * jresult ;
80130   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80131   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80132
80133   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80134   {
80135     try {
80136       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80137     } catch (std::out_of_range& e) {
80138       {
80139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80140       };
80141     } catch (std::exception& e) {
80142       {
80143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80144       };
80145     } catch (Dali::DaliException e) {
80146       {
80147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80148       };
80149     } catch (...) {
80150       {
80151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80152       };
80153     }
80154   }
80155
80156   jresult = (void *)result;
80157   return jresult;
80158 }
80159
80160
80161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80162   void * jresult ;
80163   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80164   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80165
80166   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80167   {
80168     try {
80169       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80170     } catch (std::out_of_range& e) {
80171       {
80172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80173       };
80174     } catch (std::exception& e) {
80175       {
80176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80177       };
80178     } catch (Dali::DaliException e) {
80179       {
80180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80181       };
80182     } catch (...) {
80183       {
80184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80185       };
80186     }
80187   }
80188
80189   jresult = (void *)result;
80190   return jresult;
80191 }
80192
80193
80194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80195   void * jresult ;
80196   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80197   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80198
80199   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80200   {
80201     try {
80202       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80203     } catch (std::out_of_range& e) {
80204       {
80205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80206       };
80207     } catch (std::exception& e) {
80208       {
80209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80210       };
80211     } catch (Dali::DaliException e) {
80212       {
80213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80214       };
80215     } catch (...) {
80216       {
80217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80218       };
80219     }
80220   }
80221
80222   jresult = (void *)result;
80223   return jresult;
80224 }
80225
80226
80227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80228   void * jresult ;
80229   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80230   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80231
80232   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80233   {
80234     try {
80235       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80236     } catch (std::out_of_range& e) {
80237       {
80238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80239       };
80240     } catch (std::exception& e) {
80241       {
80242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80243       };
80244     } catch (Dali::DaliException e) {
80245       {
80246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80247       };
80248     } catch (...) {
80249       {
80250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80251       };
80252     }
80253   }
80254
80255   jresult = (void *)result;
80256   return jresult;
80257 }
80258
80259
80260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80261   void * jresult ;
80262   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80263   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80264
80265   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80266   {
80267     try {
80268       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80269     } catch (std::out_of_range& e) {
80270       {
80271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80272       };
80273     } catch (std::exception& e) {
80274       {
80275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80276       };
80277     } catch (Dali::DaliException e) {
80278       {
80279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80280       };
80281     } catch (...) {
80282       {
80283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80284       };
80285     }
80286   }
80287
80288   jresult = (void *)result;
80289   return jresult;
80290 }
80291
80292
80293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80294   void * jresult ;
80295   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80296   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80297
80298   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80299   {
80300     try {
80301       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80302     } catch (std::out_of_range& e) {
80303       {
80304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80305       };
80306     } catch (std::exception& e) {
80307       {
80308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80309       };
80310     } catch (Dali::DaliException e) {
80311       {
80312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80313       };
80314     } catch (...) {
80315       {
80316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80317       };
80318     }
80319   }
80320
80321   jresult = (void *)result;
80322   return jresult;
80323 }
80324
80325
80326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80327   void * jresult ;
80328   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80329   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80330
80331   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80332   {
80333     try {
80334       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80335     } catch (std::out_of_range& e) {
80336       {
80337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80338       };
80339     } catch (std::exception& e) {
80340       {
80341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80342       };
80343     } catch (Dali::DaliException e) {
80344       {
80345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80346       };
80347     } catch (...) {
80348       {
80349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80350       };
80351     }
80352   }
80353
80354   jresult = (void *)result;
80355   return jresult;
80356 }
80357
80358
80359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80360   void * jresult ;
80361   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80362   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80363
80364   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80365   {
80366     try {
80367       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80368     } catch (std::out_of_range& e) {
80369       {
80370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80371       };
80372     } catch (std::exception& e) {
80373       {
80374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80375       };
80376     } catch (Dali::DaliException e) {
80377       {
80378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80379       };
80380     } catch (...) {
80381       {
80382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80383       };
80384     }
80385   }
80386
80387   jresult = (void *)result;
80388   return jresult;
80389 }
80390
80391
80392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
80393   void * jresult ;
80394   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80395   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80396
80397   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80398   {
80399     try {
80400       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80401     } catch (std::out_of_range& e) {
80402       {
80403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80404       };
80405     } catch (std::exception& e) {
80406       {
80407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80408       };
80409     } catch (Dali::DaliException e) {
80410       {
80411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80412       };
80413     } catch (...) {
80414       {
80415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80416       };
80417     }
80418   }
80419
80420   jresult = (void *)result;
80421   return jresult;
80422 }
80423
80424
80425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80426   void * jresult ;
80427   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80428   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80429
80430   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80431   {
80432     try {
80433       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80434     } catch (std::out_of_range& e) {
80435       {
80436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80437       };
80438     } catch (std::exception& e) {
80439       {
80440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80441       };
80442     } catch (Dali::DaliException e) {
80443       {
80444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80445       };
80446     } catch (...) {
80447       {
80448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80449       };
80450     }
80451   }
80452
80453   jresult = (void *)result;
80454   return jresult;
80455 }
80456
80457
80458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80459   void * jresult ;
80460   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80461   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80462
80463   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80464   {
80465     try {
80466       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80467     } catch (std::out_of_range& e) {
80468       {
80469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80470       };
80471     } catch (std::exception& e) {
80472       {
80473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80474       };
80475     } catch (Dali::DaliException e) {
80476       {
80477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80478       };
80479     } catch (...) {
80480       {
80481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80482       };
80483     }
80484   }
80485
80486   jresult = (void *)result;
80487   return jresult;
80488 }
80489
80490
80491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80492   void * jresult ;
80493   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80494   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80495
80496   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80497   {
80498     try {
80499       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80500     } catch (std::out_of_range& e) {
80501       {
80502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80503       };
80504     } catch (std::exception& e) {
80505       {
80506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80507       };
80508     } catch (Dali::DaliException e) {
80509       {
80510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80511       };
80512     } catch (...) {
80513       {
80514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80515       };
80516     }
80517   }
80518
80519   jresult = (void *)result;
80520   return jresult;
80521 }
80522
80523
80524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80525   void * jresult ;
80526   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80527   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80528
80529   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80530   {
80531     try {
80532       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80533     } catch (std::out_of_range& e) {
80534       {
80535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80536       };
80537     } catch (std::exception& e) {
80538       {
80539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80540       };
80541     } catch (Dali::DaliException e) {
80542       {
80543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80544       };
80545     } catch (...) {
80546       {
80547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80548       };
80549     }
80550   }
80551
80552   jresult = (void *)result;
80553   return jresult;
80554 }
80555
80556
80557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80558   void * jresult ;
80559   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80560   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80561
80562   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80563   {
80564     try {
80565       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
80566     } catch (std::out_of_range& e) {
80567       {
80568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80569       };
80570     } catch (std::exception& e) {
80571       {
80572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80573       };
80574     } catch (Dali::DaliException e) {
80575       {
80576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80577       };
80578     } catch (...) {
80579       {
80580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80581       };
80582     }
80583   }
80584
80585   jresult = (void *)result;
80586   return jresult;
80587 }
80588
80589
80590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
80591   void * jresult ;
80592   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80593   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80594
80595   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80596   {
80597     try {
80598       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
80599     } catch (std::out_of_range& e) {
80600       {
80601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80602       };
80603     } catch (std::exception& e) {
80604       {
80605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80606       };
80607     } catch (Dali::DaliException e) {
80608       {
80609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80610       };
80611     } catch (...) {
80612       {
80613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80614       };
80615     }
80616   }
80617
80618   jresult = (void *)result;
80619   return jresult;
80620 }
80621
80622
80623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80624   void * jresult ;
80625   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80626   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80627
80628   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80629   {
80630     try {
80631       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80632     } catch (std::out_of_range& e) {
80633       {
80634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80635       };
80636     } catch (std::exception& e) {
80637       {
80638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80639       };
80640     } catch (Dali::DaliException e) {
80641       {
80642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80643       };
80644     } catch (...) {
80645       {
80646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80647       };
80648     }
80649   }
80650
80651   jresult = (void *)result;
80652   return jresult;
80653 }
80654
80655
80656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80657   void * jresult ;
80658   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80659   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80660
80661   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80662   {
80663     try {
80664       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80665     } catch (std::out_of_range& e) {
80666       {
80667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80668       };
80669     } catch (std::exception& e) {
80670       {
80671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80672       };
80673     } catch (Dali::DaliException e) {
80674       {
80675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80676       };
80677     } catch (...) {
80678       {
80679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80680       };
80681     }
80682   }
80683
80684   jresult = (void *)result;
80685   return jresult;
80686 }
80687
80688
80689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80690   void * jresult ;
80691   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80692   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80693
80694   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80695   {
80696     try {
80697       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80698     } catch (std::out_of_range& e) {
80699       {
80700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80701       };
80702     } catch (std::exception& e) {
80703       {
80704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80705       };
80706     } catch (Dali::DaliException e) {
80707       {
80708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80709       };
80710     } catch (...) {
80711       {
80712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80713       };
80714     }
80715   }
80716
80717   jresult = (void *)result;
80718   return jresult;
80719 }
80720
80721
80722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80723   void * jresult ;
80724   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80725   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80726
80727   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80728   {
80729     try {
80730       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80731     } catch (std::out_of_range& e) {
80732       {
80733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80734       };
80735     } catch (std::exception& e) {
80736       {
80737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80738       };
80739     } catch (Dali::DaliException e) {
80740       {
80741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80742       };
80743     } catch (...) {
80744       {
80745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80746       };
80747     }
80748   }
80749
80750   jresult = (void *)result;
80751   return jresult;
80752 }
80753
80754
80755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80756   void * jresult ;
80757   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80758   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80759
80760   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80761   {
80762     try {
80763       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80764     } catch (std::out_of_range& e) {
80765       {
80766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80767       };
80768     } catch (std::exception& e) {
80769       {
80770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80771       };
80772     } catch (Dali::DaliException e) {
80773       {
80774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80775       };
80776     } catch (...) {
80777       {
80778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80779       };
80780     }
80781   }
80782
80783   jresult = (void *)result;
80784   return jresult;
80785 }
80786
80787
80788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
80789   void * jresult ;
80790   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80791   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80792
80793   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80794   {
80795     try {
80796       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
80797     } catch (std::out_of_range& e) {
80798       {
80799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80800       };
80801     } catch (std::exception& e) {
80802       {
80803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80804       };
80805     } catch (Dali::DaliException e) {
80806       {
80807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80808       };
80809     } catch (...) {
80810       {
80811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80812       };
80813     }
80814   }
80815
80816   jresult = (void *)result;
80817   return jresult;
80818 }
80819
80820
80821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
80822   void * jresult ;
80823   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80824   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80825
80826   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80827   {
80828     try {
80829       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
80830     } catch (std::out_of_range& e) {
80831       {
80832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80833       };
80834     } catch (std::exception& e) {
80835       {
80836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80837       };
80838     } catch (Dali::DaliException e) {
80839       {
80840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80841       };
80842     } catch (...) {
80843       {
80844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80845       };
80846     }
80847   }
80848
80849   jresult = (void *)result;
80850   return jresult;
80851 }
80852
80853
80854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
80855   void * jresult ;
80856   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80857   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
80858
80859   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80860   {
80861     try {
80862       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
80863     } catch (std::out_of_range& e) {
80864       {
80865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80866       };
80867     } catch (std::exception& e) {
80868       {
80869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80870       };
80871     } catch (Dali::DaliException e) {
80872       {
80873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80874       };
80875     } catch (...) {
80876       {
80877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80878       };
80879     }
80880   }
80881
80882   jresult = (void *)result;
80883   return jresult;
80884 }
80885
80886
80887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
80888   void * jresult ;
80889   Dali::Toolkit::StyleManager *result = 0 ;
80890
80891   {
80892     try {
80893       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
80894     } catch (std::out_of_range& e) {
80895       {
80896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80897       };
80898     } catch (std::exception& e) {
80899       {
80900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80901       };
80902     } catch (Dali::DaliException e) {
80903       {
80904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80905       };
80906     } catch (...) {
80907       {
80908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80909       };
80910     }
80911   }
80912
80913   jresult = (void *)result;
80914   return jresult;
80915 }
80916
80917
80918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
80919   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80920
80921   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80922   {
80923     try {
80924       delete arg1;
80925     } catch (std::out_of_range& e) {
80926       {
80927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80928       };
80929     } catch (std::exception& e) {
80930       {
80931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80932       };
80933     } catch (Dali::DaliException e) {
80934       {
80935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80936       };
80937     } catch (...) {
80938       {
80939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80940       };
80941     }
80942   }
80943
80944 }
80945
80946
80947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
80948   void * jresult ;
80949   Dali::Toolkit::StyleManager result;
80950
80951   {
80952     try {
80953       result = Dali::Toolkit::StyleManager::Get();
80954     } catch (std::out_of_range& e) {
80955       {
80956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80957       };
80958     } catch (std::exception& e) {
80959       {
80960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80961       };
80962     } catch (Dali::DaliException e) {
80963       {
80964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80965       };
80966     } catch (...) {
80967       {
80968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80969       };
80970     }
80971   }
80972
80973   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
80974   return jresult;
80975 }
80976
80977
80978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
80979   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80980   std::string *arg2 = 0 ;
80981
80982   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80983   if (!jarg2) {
80984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80985     return ;
80986   }
80987   std::string arg2_str(jarg2);
80988   arg2 = &arg2_str;
80989   {
80990     try {
80991       (arg1)->ApplyTheme((std::string const &)*arg2);
80992     } catch (std::out_of_range& e) {
80993       {
80994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80995       };
80996     } catch (std::exception& e) {
80997       {
80998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80999       };
81000     } catch (Dali::DaliException e) {
81001       {
81002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81003       };
81004     } catch (...) {
81005       {
81006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81007       };
81008     }
81009   }
81010
81011
81012   //argout typemap for const std::string&
81013
81014 }
81015
81016
81017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
81018   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81019
81020   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81021   {
81022     try {
81023       (arg1)->ApplyDefaultTheme();
81024     } catch (std::out_of_range& e) {
81025       {
81026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81027       };
81028     } catch (std::exception& e) {
81029       {
81030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81031       };
81032     } catch (Dali::DaliException e) {
81033       {
81034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81035       };
81036     } catch (...) {
81037       {
81038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81039       };
81040     }
81041   }
81042
81043 }
81044
81045
81046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81047   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81048   std::string *arg2 = 0 ;
81049   Dali::Property::Value *arg3 = 0 ;
81050
81051   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81052   if (!jarg2) {
81053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81054     return ;
81055   }
81056   std::string arg2_str(jarg2);
81057   arg2 = &arg2_str;
81058   arg3 = (Dali::Property::Value *)jarg3;
81059   if (!arg3) {
81060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81061     return ;
81062   }
81063   {
81064     try {
81065       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81066     } catch (std::out_of_range& e) {
81067       {
81068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81069       };
81070     } catch (std::exception& e) {
81071       {
81072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81073       };
81074     } catch (Dali::DaliException e) {
81075       {
81076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81077       };
81078     } catch (...) {
81079       {
81080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81081       };
81082     }
81083   }
81084
81085
81086   //argout typemap for const std::string&
81087
81088 }
81089
81090
81091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81092   unsigned int jresult ;
81093   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81094   std::string *arg2 = 0 ;
81095   Dali::Property::Value *arg3 = 0 ;
81096   bool result;
81097
81098   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81099   if (!jarg2) {
81100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81101     return 0;
81102   }
81103   std::string arg2_str(jarg2);
81104   arg2 = &arg2_str;
81105   arg3 = (Dali::Property::Value *)jarg3;
81106   if (!arg3) {
81107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81108     return 0;
81109   }
81110   {
81111     try {
81112       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81113     } catch (std::out_of_range& e) {
81114       {
81115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81116       };
81117     } catch (std::exception& e) {
81118       {
81119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81120       };
81121     } catch (Dali::DaliException e) {
81122       {
81123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81124       };
81125     } catch (...) {
81126       {
81127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81128       };
81129     }
81130   }
81131
81132   jresult = result;
81133
81134   //argout typemap for const std::string&
81135
81136   return jresult;
81137 }
81138
81139
81140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81141   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81142   Dali::Toolkit::Control arg2 ;
81143   std::string *arg3 = 0 ;
81144   std::string *arg4 = 0 ;
81145   Dali::Toolkit::Control *argp2 ;
81146
81147   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81148   argp2 = (Dali::Toolkit::Control *)jarg2;
81149   if (!argp2) {
81150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81151     return ;
81152   }
81153   arg2 = *argp2;
81154   if (!jarg3) {
81155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81156     return ;
81157   }
81158   std::string arg3_str(jarg3);
81159   arg3 = &arg3_str;
81160   if (!jarg4) {
81161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81162     return ;
81163   }
81164   std::string arg4_str(jarg4);
81165   arg4 = &arg4_str;
81166   {
81167     try {
81168       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81169     } catch (std::out_of_range& e) {
81170       {
81171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81172       };
81173     } catch (std::exception& e) {
81174       {
81175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81176       };
81177     } catch (Dali::DaliException e) {
81178       {
81179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81180       };
81181     } catch (...) {
81182       {
81183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81184       };
81185     }
81186   }
81187
81188
81189   //argout typemap for const std::string&
81190
81191
81192   //argout typemap for const std::string&
81193
81194 }
81195
81196
81197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81198   void * jresult ;
81199   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81200   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81201
81202   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81203   {
81204     try {
81205       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81206     } catch (std::out_of_range& e) {
81207       {
81208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81209       };
81210     } catch (std::exception& e) {
81211       {
81212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81213       };
81214     } catch (Dali::DaliException e) {
81215       {
81216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81217       };
81218     } catch (...) {
81219       {
81220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81221       };
81222     }
81223   }
81224
81225   jresult = (void *)result;
81226   return jresult;
81227 }
81228
81229
81230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81231   int jresult ;
81232   int result;
81233
81234   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81235   jresult = (int)result;
81236   return jresult;
81237 }
81238
81239
81240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81241   int jresult ;
81242   int result;
81243
81244   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81245   jresult = (int)result;
81246   return jresult;
81247 }
81248
81249
81250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81251   int jresult ;
81252   int result;
81253
81254   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81255   jresult = (int)result;
81256   return jresult;
81257 }
81258
81259
81260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81261   int jresult ;
81262   int result;
81263
81264   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81265   jresult = (int)result;
81266   return jresult;
81267 }
81268
81269
81270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81271   int jresult ;
81272   int result;
81273
81274   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81275   jresult = (int)result;
81276   return jresult;
81277 }
81278
81279
81280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81281   int jresult ;
81282   int result;
81283
81284   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81285   jresult = (int)result;
81286   return jresult;
81287 }
81288
81289
81290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81291   int jresult ;
81292   int result;
81293
81294   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81295   jresult = (int)result;
81296   return jresult;
81297 }
81298
81299
81300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81301   int jresult ;
81302   int result;
81303
81304   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81305   jresult = (int)result;
81306   return jresult;
81307 }
81308
81309
81310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81311   int jresult ;
81312   int result;
81313
81314   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81315   jresult = (int)result;
81316   return jresult;
81317 }
81318
81319
81320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81321   int jresult ;
81322   int result;
81323
81324   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81325   jresult = (int)result;
81326   return jresult;
81327 }
81328
81329
81330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81331   int jresult ;
81332   int result;
81333
81334   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81335   jresult = (int)result;
81336   return jresult;
81337 }
81338
81339
81340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81341   int jresult ;
81342   int result;
81343
81344   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81345   jresult = (int)result;
81346   return jresult;
81347 }
81348
81349
81350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81351   int jresult ;
81352   int result;
81353
81354   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81355   jresult = (int)result;
81356   return jresult;
81357 }
81358
81359
81360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81361   int jresult ;
81362   int result;
81363
81364   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81365   jresult = (int)result;
81366   return jresult;
81367 }
81368
81369
81370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81371   int jresult ;
81372   int result;
81373
81374   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81375   jresult = (int)result;
81376   return jresult;
81377 }
81378
81379
81380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81381   void * jresult ;
81382   Dali::Toolkit::Slider::Property *result = 0 ;
81383
81384   {
81385     try {
81386       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81387     } catch (std::out_of_range& e) {
81388       {
81389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81390       };
81391     } catch (std::exception& e) {
81392       {
81393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81394       };
81395     } catch (Dali::DaliException e) {
81396       {
81397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81398       };
81399     } catch (...) {
81400       {
81401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81402       };
81403     }
81404   }
81405
81406   jresult = (void *)result;
81407   return jresult;
81408 }
81409
81410
81411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81412   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81413
81414   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81415   {
81416     try {
81417       delete arg1;
81418     } catch (std::out_of_range& e) {
81419       {
81420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81421       };
81422     } catch (std::exception& e) {
81423       {
81424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81425       };
81426     } catch (Dali::DaliException e) {
81427       {
81428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81429       };
81430     } catch (...) {
81431       {
81432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81433       };
81434     }
81435   }
81436
81437 }
81438
81439
81440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81441   void * jresult ;
81442   Dali::Toolkit::Slider result;
81443
81444   {
81445     try {
81446       result = Dali::Toolkit::Slider::New();
81447     } catch (std::out_of_range& e) {
81448       {
81449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81450       };
81451     } catch (std::exception& e) {
81452       {
81453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81454       };
81455     } catch (Dali::DaliException e) {
81456       {
81457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81458       };
81459     } catch (...) {
81460       {
81461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81462       };
81463     }
81464   }
81465
81466   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81467   return jresult;
81468 }
81469
81470
81471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81472   void * jresult ;
81473   Dali::Toolkit::Slider *result = 0 ;
81474
81475   {
81476     try {
81477       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81478     } catch (std::out_of_range& e) {
81479       {
81480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81481       };
81482     } catch (std::exception& e) {
81483       {
81484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81485       };
81486     } catch (Dali::DaliException e) {
81487       {
81488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81489       };
81490     } catch (...) {
81491       {
81492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81493       };
81494     }
81495   }
81496
81497   jresult = (void *)result;
81498   return jresult;
81499 }
81500
81501
81502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
81503   void * jresult ;
81504   Dali::Toolkit::Slider *arg1 = 0 ;
81505   Dali::Toolkit::Slider *result = 0 ;
81506
81507   arg1 = (Dali::Toolkit::Slider *)jarg1;
81508   if (!arg1) {
81509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81510     return 0;
81511   }
81512   {
81513     try {
81514       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81515     } catch (std::out_of_range& e) {
81516       {
81517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81518       };
81519     } catch (std::exception& e) {
81520       {
81521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81522       };
81523     } catch (Dali::DaliException e) {
81524       {
81525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81526       };
81527     } catch (...) {
81528       {
81529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81530       };
81531     }
81532   }
81533
81534   jresult = (void *)result;
81535   return jresult;
81536 }
81537
81538
81539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
81540   void * jresult ;
81541   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81542   Dali::Toolkit::Slider *arg2 = 0 ;
81543   Dali::Toolkit::Slider *result = 0 ;
81544
81545   arg1 = (Dali::Toolkit::Slider *)jarg1;
81546   arg2 = (Dali::Toolkit::Slider *)jarg2;
81547   if (!arg2) {
81548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81549     return 0;
81550   }
81551   {
81552     try {
81553       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81554     } catch (std::out_of_range& e) {
81555       {
81556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81557       };
81558     } catch (std::exception& e) {
81559       {
81560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81561       };
81562     } catch (Dali::DaliException e) {
81563       {
81564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81565       };
81566     } catch (...) {
81567       {
81568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81569       };
81570     }
81571   }
81572
81573   jresult = (void *)result;
81574   return jresult;
81575 }
81576
81577
81578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
81579   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81580
81581   arg1 = (Dali::Toolkit::Slider *)jarg1;
81582   {
81583     try {
81584       delete arg1;
81585     } catch (std::out_of_range& e) {
81586       {
81587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81588       };
81589     } catch (std::exception& e) {
81590       {
81591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81592       };
81593     } catch (Dali::DaliException e) {
81594       {
81595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81596       };
81597     } catch (...) {
81598       {
81599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81600       };
81601     }
81602   }
81603
81604 }
81605
81606
81607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
81608   void * jresult ;
81609   Dali::BaseHandle arg1 ;
81610   Dali::BaseHandle *argp1 ;
81611   Dali::Toolkit::Slider result;
81612
81613   argp1 = (Dali::BaseHandle *)jarg1;
81614   if (!argp1) {
81615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81616     return 0;
81617   }
81618   arg1 = *argp1;
81619   {
81620     try {
81621       result = Dali::Toolkit::Slider::DownCast(arg1);
81622     } catch (std::out_of_range& e) {
81623       {
81624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81625       };
81626     } catch (std::exception& e) {
81627       {
81628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81629       };
81630     } catch (Dali::DaliException e) {
81631       {
81632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81633       };
81634     } catch (...) {
81635       {
81636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81637       };
81638     }
81639   }
81640
81641   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81642   return jresult;
81643 }
81644
81645
81646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
81647   void * jresult ;
81648   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81649   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81650
81651   arg1 = (Dali::Toolkit::Slider *)jarg1;
81652   {
81653     try {
81654       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
81655     } catch (std::out_of_range& e) {
81656       {
81657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81658       };
81659     } catch (std::exception& e) {
81660       {
81661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81662       };
81663     } catch (Dali::DaliException e) {
81664       {
81665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81666       };
81667     } catch (...) {
81668       {
81669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81670       };
81671     }
81672   }
81673
81674   jresult = (void *)result;
81675   return jresult;
81676 }
81677
81678
81679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
81680   void * jresult ;
81681   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81682   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81683
81684   arg1 = (Dali::Toolkit::Slider *)jarg1;
81685   {
81686     try {
81687       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
81688     } catch (std::out_of_range& e) {
81689       {
81690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81691       };
81692     } catch (std::exception& e) {
81693       {
81694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81695       };
81696     } catch (Dali::DaliException e) {
81697       {
81698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81699       };
81700     } catch (...) {
81701       {
81702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81703       };
81704     }
81705   }
81706
81707   jresult = (void *)result;
81708   return jresult;
81709 }
81710
81711
81712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
81713   void * jresult ;
81714   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81715   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
81716
81717   arg1 = (Dali::Toolkit::Slider *)jarg1;
81718   {
81719     try {
81720       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
81721     } catch (std::out_of_range& e) {
81722       {
81723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81724       };
81725     } catch (std::exception& e) {
81726       {
81727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81728       };
81729     } catch (Dali::DaliException e) {
81730       {
81731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81732       };
81733     } catch (...) {
81734       {
81735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81736       };
81737     }
81738   }
81739
81740   jresult = (void *)result;
81741   return jresult;
81742 }
81743
81744
81745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
81746   int jresult ;
81747   int result;
81748
81749   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81750   jresult = (int)result;
81751   return jresult;
81752 }
81753
81754
81755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
81756   int jresult ;
81757   int result;
81758
81759   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81760   jresult = (int)result;
81761   return jresult;
81762 }
81763
81764
81765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
81766   int jresult ;
81767   int result;
81768
81769   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81770   jresult = (int)result;
81771   return jresult;
81772 }
81773
81774
81775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
81776   int jresult ;
81777   int result;
81778
81779   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81780   jresult = (int)result;
81781   return jresult;
81782 }
81783
81784
81785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
81786   int result;
81787
81788   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
81789
81790   return result;
81791 }
81792
81793
81794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
81795   void * jresult ;
81796   Dali::Toolkit::VideoView::Property *result = 0 ;
81797
81798   {
81799     try {
81800       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
81801     } catch (std::out_of_range& e) {
81802       {
81803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81804       };
81805     } catch (std::exception& e) {
81806       {
81807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81808       };
81809     } catch (Dali::DaliException e) {
81810       {
81811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81812       };
81813     } catch (...) {
81814       {
81815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81816       };
81817     }
81818   }
81819
81820   jresult = (void *)result;
81821   return jresult;
81822 }
81823
81824
81825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
81826   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81827
81828   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
81829   {
81830     try {
81831       delete arg1;
81832     } catch (std::out_of_range& e) {
81833       {
81834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81835       };
81836     } catch (std::exception& e) {
81837       {
81838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81839       };
81840     } catch (Dali::DaliException e) {
81841       {
81842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81843       };
81844     } catch (...) {
81845       {
81846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81847       };
81848     }
81849   }
81850
81851 }
81852
81853
81854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
81855   void * jresult ;
81856   Dali::Toolkit::VideoView result;
81857
81858   {
81859     try {
81860       result = Dali::Toolkit::VideoView::New();
81861     } catch (std::out_of_range& e) {
81862       {
81863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81864       };
81865     } catch (std::exception& e) {
81866       {
81867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81868       };
81869     } catch (Dali::DaliException e) {
81870       {
81871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81872       };
81873     } catch (...) {
81874       {
81875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81876       };
81877     }
81878   }
81879
81880   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81881   return jresult;
81882 }
81883
81884
81885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
81886   void * jresult ;
81887   std::string *arg1 = 0 ;
81888   Dali::Toolkit::VideoView result;
81889
81890   if (!jarg1) {
81891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81892     return 0;
81893   }
81894   std::string arg1_str(jarg1);
81895   arg1 = &arg1_str;
81896   {
81897     try {
81898       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81899     } catch (std::out_of_range& e) {
81900       {
81901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81902       };
81903     } catch (std::exception& e) {
81904       {
81905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81906       };
81907     } catch (Dali::DaliException e) {
81908       {
81909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81910       };
81911     } catch (...) {
81912       {
81913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81914       };
81915     }
81916   }
81917
81918   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81919
81920   //argout typemap for const std::string&
81921
81922   return jresult;
81923 }
81924
81925
81926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
81927   void * jresult ;
81928   Dali::Toolkit::VideoView result;
81929   {
81930     try {
81931       result = Dali::Toolkit::VideoView::New(swCodec);
81932     } catch (std::out_of_range& e) {
81933       {
81934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81935       };
81936     } catch (std::exception& e) {
81937       {
81938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81939       };
81940     } catch (Dali::DaliException e) {
81941       {
81942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81943       };
81944     } catch (...) {
81945       {
81946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81947       };
81948     }
81949   }
81950
81951   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81952
81953   //argout typemap for const std::string&
81954
81955   return jresult;
81956 }
81957
81958
81959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
81960   void * jresult ;
81961   std::string *arg1 = 0 ;
81962   Dali::Toolkit::VideoView result;
81963
81964   if (!jarg1) {
81965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81966     return 0;
81967   }
81968   std::string arg1_str(jarg1);
81969   arg1 = &arg1_str;
81970   {
81971     try {
81972       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
81973     } catch (std::out_of_range& e) {
81974       {
81975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81976       };
81977     } catch (std::exception& e) {
81978       {
81979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81980       };
81981     } catch (Dali::DaliException e) {
81982       {
81983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81984       };
81985     } catch (...) {
81986       {
81987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81988       };
81989     }
81990   }
81991
81992   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81993
81994   //argout typemap for const std::string&
81995
81996   return jresult;
81997 }
81998
81999
82000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
82001   void * jresult ;
82002   Dali::Toolkit::VideoView *result = 0 ;
82003
82004   {
82005     try {
82006       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
82007     } catch (std::out_of_range& e) {
82008       {
82009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82010       };
82011     } catch (std::exception& e) {
82012       {
82013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82014       };
82015     } catch (Dali::DaliException e) {
82016       {
82017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82018       };
82019     } catch (...) {
82020       {
82021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82022       };
82023     }
82024   }
82025
82026   jresult = (void *)result;
82027   return jresult;
82028 }
82029
82030
82031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
82032   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82033
82034   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82035   {
82036     try {
82037       delete arg1;
82038     } catch (std::out_of_range& e) {
82039       {
82040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82041       };
82042     } catch (std::exception& e) {
82043       {
82044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82045       };
82046     } catch (Dali::DaliException e) {
82047       {
82048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82049       };
82050     } catch (...) {
82051       {
82052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82053       };
82054     }
82055   }
82056
82057 }
82058
82059
82060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
82061   void * jresult ;
82062   Dali::Toolkit::VideoView *arg1 = 0 ;
82063   Dali::Toolkit::VideoView *result = 0 ;
82064
82065   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82066   if (!arg1) {
82067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82068     return 0;
82069   }
82070   {
82071     try {
82072       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
82073     } catch (std::out_of_range& e) {
82074       {
82075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82076       };
82077     } catch (std::exception& e) {
82078       {
82079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82080       };
82081     } catch (Dali::DaliException e) {
82082       {
82083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82084       };
82085     } catch (...) {
82086       {
82087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82088       };
82089     }
82090   }
82091
82092   jresult = (void *)result;
82093   return jresult;
82094 }
82095
82096
82097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82098   void * jresult ;
82099   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82100   Dali::Toolkit::VideoView *arg2 = 0 ;
82101   Dali::Toolkit::VideoView *result = 0 ;
82102
82103   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82104   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82105   if (!arg2) {
82106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82107     return 0;
82108   }
82109   {
82110     try {
82111       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82112     } catch (std::out_of_range& e) {
82113       {
82114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82115       };
82116     } catch (std::exception& e) {
82117       {
82118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82119       };
82120     } catch (Dali::DaliException e) {
82121       {
82122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82123       };
82124     } catch (...) {
82125       {
82126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82127       };
82128     }
82129   }
82130
82131   jresult = (void *)result;
82132   return jresult;
82133 }
82134
82135
82136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82137   void * jresult ;
82138   Dali::BaseHandle arg1 ;
82139   Dali::BaseHandle *argp1 ;
82140   Dali::Toolkit::VideoView result;
82141
82142   argp1 = (Dali::BaseHandle *)jarg1;
82143   if (!argp1) {
82144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82145     return 0;
82146   }
82147   arg1 = *argp1;
82148   {
82149     try {
82150       result = Dali::Toolkit::VideoView::DownCast(arg1);
82151     } catch (std::out_of_range& e) {
82152       {
82153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82154       };
82155     } catch (std::exception& e) {
82156       {
82157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82158       };
82159     } catch (Dali::DaliException e) {
82160       {
82161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82162       };
82163     } catch (...) {
82164       {
82165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82166       };
82167     }
82168   }
82169
82170   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82171   return jresult;
82172 }
82173
82174
82175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82176   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82177
82178   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82179   {
82180     try {
82181       (arg1)->Play();
82182     } catch (std::out_of_range& e) {
82183       {
82184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82185       };
82186     } catch (std::exception& e) {
82187       {
82188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82189       };
82190     } catch (Dali::DaliException e) {
82191       {
82192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82193       };
82194     } catch (...) {
82195       {
82196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82197       };
82198     }
82199   }
82200
82201 }
82202
82203
82204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82205   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82206
82207   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82208   {
82209     try {
82210       (arg1)->Pause();
82211     } catch (std::out_of_range& e) {
82212       {
82213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82214       };
82215     } catch (std::exception& e) {
82216       {
82217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82218       };
82219     } catch (Dali::DaliException e) {
82220       {
82221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82222       };
82223     } catch (...) {
82224       {
82225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82226       };
82227     }
82228   }
82229
82230 }
82231
82232
82233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82234   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82235
82236   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82237   {
82238     try {
82239       (arg1)->Stop();
82240     } catch (std::out_of_range& e) {
82241       {
82242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82243       };
82244     } catch (std::exception& e) {
82245       {
82246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82247       };
82248     } catch (Dali::DaliException e) {
82249       {
82250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82251       };
82252     } catch (...) {
82253       {
82254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82255       };
82256     }
82257   }
82258
82259 }
82260
82261
82262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82263   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82264   int arg2 ;
82265
82266   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82267   arg2 = (int)jarg2;
82268   {
82269     try {
82270       (arg1)->Forward(arg2);
82271     } catch (std::out_of_range& e) {
82272       {
82273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82274       };
82275     } catch (std::exception& e) {
82276       {
82277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82278       };
82279     } catch (Dali::DaliException e) {
82280       {
82281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82282       };
82283     } catch (...) {
82284       {
82285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82286       };
82287     }
82288   }
82289
82290 }
82291
82292
82293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82294   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82295   int arg2 ;
82296
82297   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82298   arg2 = (int)jarg2;
82299   {
82300     try {
82301       (arg1)->Backward(arg2);
82302     } catch (std::out_of_range& e) {
82303       {
82304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82305       };
82306     } catch (std::exception& e) {
82307       {
82308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82309       };
82310     } catch (Dali::DaliException e) {
82311       {
82312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82313       };
82314     } catch (...) {
82315       {
82316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82317       };
82318     }
82319   }
82320
82321 }
82322
82323
82324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82325   void * jresult ;
82326   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82327   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82328
82329   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82330   {
82331     try {
82332       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82333     } catch (std::out_of_range& e) {
82334       {
82335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82336       };
82337     } catch (std::exception& e) {
82338       {
82339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82340       };
82341     } catch (Dali::DaliException e) {
82342       {
82343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82344       };
82345     } catch (...) {
82346       {
82347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82348       };
82349     }
82350   }
82351
82352   jresult = (void *)result;
82353   return jresult;
82354 }
82355
82356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
82357 {
82358   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
82359   if( arg1 == nullptr )
82360   {
82361     DALI_LOG_ERROR("VideoView is nullptr!");
82362     return nullptr;
82363   }
82364   void * ret = nullptr;
82365   {
82366     try{
82367
82368       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
82369       ret = Dali::AnyCast< void * >( result );
82370
82371     } catch (std::out_of_range& e) {
82372       {
82373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82374       };
82375     } catch (std::exception& e) {
82376       {
82377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82378       };
82379     } catch (Dali::DaliException e) {
82380       {
82381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82382       };
82383     } catch (...) {
82384       {
82385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82386       };
82387     }
82388   }
82389   return ret;
82390 }
82391
82392
82393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82394   int jresult ;
82395   int result;
82396
82397   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82398   jresult = (int)result;
82399   return jresult;
82400 }
82401
82402
82403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82404   int jresult ;
82405   int result;
82406
82407   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82408   jresult = (int)result;
82409   return jresult;
82410 }
82411
82412
82413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82414   int jresult ;
82415   int result;
82416
82417   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82418   jresult = (int)result;
82419   return jresult;
82420 }
82421
82422
82423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82424   int jresult ;
82425   int result;
82426
82427   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82428   jresult = (int)result;
82429   return jresult;
82430 }
82431
82432
82433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82434   int jresult ;
82435   int result;
82436
82437   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82438   jresult = (int)result;
82439   return jresult;
82440 }
82441
82442
82443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82444   int jresult ;
82445   int result;
82446
82447   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82448   jresult = (int)result;
82449   return jresult;
82450 }
82451
82452
82453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82454   int jresult ;
82455   int result;
82456
82457   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82458   jresult = (int)result;
82459   return jresult;
82460 }
82461
82462
82463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82464   int jresult ;
82465   int result;
82466
82467   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82468   jresult = (int)result;
82469   return jresult;
82470 }
82471
82472
82473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82474   int jresult ;
82475   int result;
82476
82477   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82478   jresult = (int)result;
82479   return jresult;
82480 }
82481
82482
82483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82484   int jresult ;
82485   int result;
82486
82487   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82488   jresult = (int)result;
82489   return jresult;
82490 }
82491
82492
82493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82494   int jresult ;
82495   int result;
82496
82497   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82498   jresult = (int)result;
82499   return jresult;
82500 }
82501
82502
82503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82504   int jresult ;
82505   int result;
82506
82507   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82508   jresult = (int)result;
82509   return jresult;
82510 }
82511
82512
82513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82514   int jresult ;
82515   int result;
82516
82517   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82518   jresult = (int)result;
82519   return jresult;
82520 }
82521
82522
82523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82524   int jresult ;
82525   int result;
82526
82527   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82528   jresult = (int)result;
82529   return jresult;
82530 }
82531
82532
82533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82534   int jresult ;
82535   int result;
82536
82537   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82538   jresult = (int)result;
82539   return jresult;
82540 }
82541
82542
82543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82544   int jresult ;
82545   int result;
82546
82547   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82548   jresult = (int)result;
82549   return jresult;
82550 }
82551
82552
82553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82554   int jresult ;
82555   int result;
82556
82557   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82558   jresult = (int)result;
82559   return jresult;
82560 }
82561
82562
82563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82564   int jresult ;
82565   int result;
82566
82567   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82568   jresult = (int)result;
82569   return jresult;
82570 }
82571
82572
82573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82574   int jresult ;
82575   int result;
82576
82577   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82578   jresult = (int)result;
82579   return jresult;
82580 }
82581
82582
82583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82584   int jresult ;
82585   int result;
82586
82587   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82588   jresult = (int)result;
82589   return jresult;
82590 }
82591
82592
82593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82594   int jresult ;
82595   int result;
82596
82597   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82598   jresult = (int)result;
82599   return jresult;
82600 }
82601
82602
82603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82604   void * jresult ;
82605   Dali::Toolkit::Popup::Property *result = 0 ;
82606
82607   {
82608     try {
82609       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82610     } catch (std::out_of_range& e) {
82611       {
82612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82613       };
82614     } catch (std::exception& e) {
82615       {
82616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82617       };
82618     } catch (Dali::DaliException e) {
82619       {
82620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82621       };
82622     } catch (...) {
82623       {
82624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82625       };
82626     }
82627   }
82628
82629   jresult = (void *)result;
82630   return jresult;
82631 }
82632
82633
82634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82635   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82636
82637   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82638   {
82639     try {
82640       delete arg1;
82641     } catch (std::out_of_range& e) {
82642       {
82643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82644       };
82645     } catch (std::exception& e) {
82646       {
82647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82648       };
82649     } catch (Dali::DaliException e) {
82650       {
82651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82652       };
82653     } catch (...) {
82654       {
82655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82656       };
82657     }
82658   }
82659
82660 }
82661
82662
82663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82664   void * jresult ;
82665   Dali::Toolkit::Popup *result = 0 ;
82666
82667   {
82668     try {
82669       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82670     } catch (std::out_of_range& e) {
82671       {
82672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82673       };
82674     } catch (std::exception& e) {
82675       {
82676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82677       };
82678     } catch (Dali::DaliException e) {
82679       {
82680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82681       };
82682     } catch (...) {
82683       {
82684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82685       };
82686     }
82687   }
82688
82689   jresult = (void *)result;
82690   return jresult;
82691 }
82692
82693
82694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82695   void * jresult ;
82696   Dali::Toolkit::Popup result;
82697
82698   {
82699     try {
82700       result = Dali::Toolkit::Popup::New();
82701     } catch (std::out_of_range& e) {
82702       {
82703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82704       };
82705     } catch (std::exception& e) {
82706       {
82707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82708       };
82709     } catch (Dali::DaliException e) {
82710       {
82711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82712       };
82713     } catch (...) {
82714       {
82715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82716       };
82717     }
82718   }
82719
82720   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82721   return jresult;
82722 }
82723
82724
82725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82726   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82727
82728   arg1 = (Dali::Toolkit::Popup *)jarg1;
82729   {
82730     try {
82731       delete arg1;
82732     } catch (std::out_of_range& e) {
82733       {
82734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82735       };
82736     } catch (std::exception& e) {
82737       {
82738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82739       };
82740     } catch (Dali::DaliException e) {
82741       {
82742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82743       };
82744     } catch (...) {
82745       {
82746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82747       };
82748     }
82749   }
82750
82751 }
82752
82753
82754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
82755   void * jresult ;
82756   Dali::Toolkit::Popup *arg1 = 0 ;
82757   Dali::Toolkit::Popup *result = 0 ;
82758
82759   arg1 = (Dali::Toolkit::Popup *)jarg1;
82760   if (!arg1) {
82761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82762     return 0;
82763   }
82764   {
82765     try {
82766       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
82767     } catch (std::out_of_range& e) {
82768       {
82769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82770       };
82771     } catch (std::exception& e) {
82772       {
82773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82774       };
82775     } catch (Dali::DaliException e) {
82776       {
82777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82778       };
82779     } catch (...) {
82780       {
82781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82782       };
82783     }
82784   }
82785
82786   jresult = (void *)result;
82787   return jresult;
82788 }
82789
82790
82791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
82792   void * jresult ;
82793   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82794   Dali::Toolkit::Popup *arg2 = 0 ;
82795   Dali::Toolkit::Popup *result = 0 ;
82796
82797   arg1 = (Dali::Toolkit::Popup *)jarg1;
82798   arg2 = (Dali::Toolkit::Popup *)jarg2;
82799   if (!arg2) {
82800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82801     return 0;
82802   }
82803   {
82804     try {
82805       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
82806     } catch (std::out_of_range& e) {
82807       {
82808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82809       };
82810     } catch (std::exception& e) {
82811       {
82812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82813       };
82814     } catch (Dali::DaliException e) {
82815       {
82816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82817       };
82818     } catch (...) {
82819       {
82820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82821       };
82822     }
82823   }
82824
82825   jresult = (void *)result;
82826   return jresult;
82827 }
82828
82829
82830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
82831   void * jresult ;
82832   Dali::BaseHandle arg1 ;
82833   Dali::BaseHandle *argp1 ;
82834   Dali::Toolkit::Popup result;
82835
82836   argp1 = (Dali::BaseHandle *)jarg1;
82837   if (!argp1) {
82838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82839     return 0;
82840   }
82841   arg1 = *argp1;
82842   {
82843     try {
82844       result = Dali::Toolkit::Popup::DownCast(arg1);
82845     } catch (std::out_of_range& e) {
82846       {
82847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82848       };
82849     } catch (std::exception& e) {
82850       {
82851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82852       };
82853     } catch (Dali::DaliException e) {
82854       {
82855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82856       };
82857     } catch (...) {
82858       {
82859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82860       };
82861     }
82862   }
82863
82864   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82865   return jresult;
82866 }
82867
82868
82869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
82870   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82871   Dali::Actor arg2 ;
82872   Dali::Actor *argp2 ;
82873
82874   arg1 = (Dali::Toolkit::Popup *)jarg1;
82875   argp2 = (Dali::Actor *)jarg2;
82876   if (!argp2) {
82877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82878     return ;
82879   }
82880   arg2 = *argp2;
82881   {
82882     try {
82883       (arg1)->SetTitle(arg2);
82884     } catch (std::out_of_range& e) {
82885       {
82886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82887       };
82888     } catch (std::exception& e) {
82889       {
82890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82891       };
82892     } catch (Dali::DaliException e) {
82893       {
82894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82895       };
82896     } catch (...) {
82897       {
82898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82899       };
82900     }
82901   }
82902
82903 }
82904
82905
82906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
82907   void * jresult ;
82908   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82909   Dali::Actor result;
82910
82911   arg1 = (Dali::Toolkit::Popup *)jarg1;
82912   {
82913     try {
82914       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
82915     } catch (std::out_of_range& e) {
82916       {
82917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82918       };
82919     } catch (std::exception& e) {
82920       {
82921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82922       };
82923     } catch (Dali::DaliException e) {
82924       {
82925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82926       };
82927     } catch (...) {
82928       {
82929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82930       };
82931     }
82932   }
82933
82934   jresult = new Dali::Actor((const Dali::Actor &)result);
82935   return jresult;
82936 }
82937
82938
82939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
82940   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82941   Dali::Actor arg2 ;
82942   Dali::Actor *argp2 ;
82943
82944   arg1 = (Dali::Toolkit::Popup *)jarg1;
82945   argp2 = (Dali::Actor *)jarg2;
82946   if (!argp2) {
82947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82948     return ;
82949   }
82950   arg2 = *argp2;
82951   {
82952     try {
82953       (arg1)->SetContent(arg2);
82954     } catch (std::out_of_range& e) {
82955       {
82956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82957       };
82958     } catch (std::exception& e) {
82959       {
82960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82961       };
82962     } catch (Dali::DaliException e) {
82963       {
82964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82965       };
82966     } catch (...) {
82967       {
82968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82969       };
82970     }
82971   }
82972
82973 }
82974
82975
82976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
82977   void * jresult ;
82978   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82979   Dali::Actor result;
82980
82981   arg1 = (Dali::Toolkit::Popup *)jarg1;
82982   {
82983     try {
82984       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
82985     } catch (std::out_of_range& e) {
82986       {
82987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82988       };
82989     } catch (std::exception& e) {
82990       {
82991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82992       };
82993     } catch (Dali::DaliException e) {
82994       {
82995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82996       };
82997     } catch (...) {
82998       {
82999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83000       };
83001     }
83002   }
83003
83004   jresult = new Dali::Actor((const Dali::Actor &)result);
83005   return jresult;
83006 }
83007
83008
83009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
83010   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83011   Dali::Actor arg2 ;
83012   Dali::Actor *argp2 ;
83013
83014   arg1 = (Dali::Toolkit::Popup *)jarg1;
83015   argp2 = (Dali::Actor *)jarg2;
83016   if (!argp2) {
83017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83018     return ;
83019   }
83020   arg2 = *argp2;
83021   {
83022     try {
83023       (arg1)->SetFooter(arg2);
83024     } catch (std::out_of_range& e) {
83025       {
83026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83027       };
83028     } catch (std::exception& e) {
83029       {
83030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83031       };
83032     } catch (Dali::DaliException e) {
83033       {
83034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83035       };
83036     } catch (...) {
83037       {
83038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83039       };
83040     }
83041   }
83042
83043 }
83044
83045
83046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
83047   void * jresult ;
83048   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83049   Dali::Actor result;
83050
83051   arg1 = (Dali::Toolkit::Popup *)jarg1;
83052   {
83053     try {
83054       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
83055     } catch (std::out_of_range& e) {
83056       {
83057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83058       };
83059     } catch (std::exception& e) {
83060       {
83061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83062       };
83063     } catch (Dali::DaliException e) {
83064       {
83065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83066       };
83067     } catch (...) {
83068       {
83069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83070       };
83071     }
83072   }
83073
83074   jresult = new Dali::Actor((const Dali::Actor &)result);
83075   return jresult;
83076 }
83077
83078
83079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
83080   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83081   Dali::Toolkit::Popup::DisplayState arg2 ;
83082
83083   arg1 = (Dali::Toolkit::Popup *)jarg1;
83084   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
83085   {
83086     try {
83087       (arg1)->SetDisplayState(arg2);
83088     } catch (std::out_of_range& e) {
83089       {
83090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83091       };
83092     } catch (std::exception& e) {
83093       {
83094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83095       };
83096     } catch (Dali::DaliException e) {
83097       {
83098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83099       };
83100     } catch (...) {
83101       {
83102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83103       };
83104     }
83105   }
83106
83107 }
83108
83109
83110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83111   int jresult ;
83112   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83113   Dali::Toolkit::Popup::DisplayState result;
83114
83115   arg1 = (Dali::Toolkit::Popup *)jarg1;
83116   {
83117     try {
83118       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83119     } catch (std::out_of_range& e) {
83120       {
83121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83122       };
83123     } catch (std::exception& e) {
83124       {
83125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83126       };
83127     } catch (Dali::DaliException e) {
83128       {
83129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83130       };
83131     } catch (...) {
83132       {
83133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83134       };
83135     }
83136   }
83137
83138   jresult = (int)result;
83139   return jresult;
83140 }
83141
83142
83143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83144   void * jresult ;
83145   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83146   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83147
83148   arg1 = (Dali::Toolkit::Popup *)jarg1;
83149   {
83150     try {
83151       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83152     } catch (std::out_of_range& e) {
83153       {
83154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83155       };
83156     } catch (std::exception& e) {
83157       {
83158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83159       };
83160     } catch (Dali::DaliException e) {
83161       {
83162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83163       };
83164     } catch (...) {
83165       {
83166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83167       };
83168     }
83169   }
83170
83171   jresult = (void *)result;
83172   return jresult;
83173 }
83174
83175
83176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83177   void * jresult ;
83178   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83179   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83180
83181   arg1 = (Dali::Toolkit::Popup *)jarg1;
83182   {
83183     try {
83184       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83185     } catch (std::out_of_range& e) {
83186       {
83187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83188       };
83189     } catch (std::exception& e) {
83190       {
83191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83192       };
83193     } catch (Dali::DaliException e) {
83194       {
83195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83196       };
83197     } catch (...) {
83198       {
83199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83200       };
83201     }
83202   }
83203
83204   jresult = (void *)result;
83205   return jresult;
83206 }
83207
83208
83209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83210   void * jresult ;
83211   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83212   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83213
83214   arg1 = (Dali::Toolkit::Popup *)jarg1;
83215   {
83216     try {
83217       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83218     } catch (std::out_of_range& e) {
83219       {
83220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83221       };
83222     } catch (std::exception& e) {
83223       {
83224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83225       };
83226     } catch (Dali::DaliException e) {
83227       {
83228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83229       };
83230     } catch (...) {
83231       {
83232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83233       };
83234     }
83235   }
83236
83237   jresult = (void *)result;
83238   return jresult;
83239 }
83240
83241
83242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83243   void * jresult ;
83244   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83245   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83246
83247   arg1 = (Dali::Toolkit::Popup *)jarg1;
83248   {
83249     try {
83250       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83251     } catch (std::out_of_range& e) {
83252       {
83253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83254       };
83255     } catch (std::exception& e) {
83256       {
83257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83258       };
83259     } catch (Dali::DaliException e) {
83260       {
83261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83262       };
83263     } catch (...) {
83264       {
83265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83266       };
83267     }
83268   }
83269
83270   jresult = (void *)result;
83271   return jresult;
83272 }
83273
83274
83275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83276   void * jresult ;
83277   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83278   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83279
83280   arg1 = (Dali::Toolkit::Popup *)jarg1;
83281   {
83282     try {
83283       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83284     } catch (std::out_of_range& e) {
83285       {
83286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83287       };
83288     } catch (std::exception& e) {
83289       {
83290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83291       };
83292     } catch (Dali::DaliException e) {
83293       {
83294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83295       };
83296     } catch (...) {
83297       {
83298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83299       };
83300     }
83301   }
83302
83303   jresult = (void *)result;
83304   return jresult;
83305 }
83306
83307
83308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83309   int jresult ;
83310   int result;
83311
83312   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83313   jresult = (int)result;
83314   return jresult;
83315 }
83316
83317
83318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83319   int jresult ;
83320   int result;
83321
83322   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83323   jresult = (int)result;
83324   return jresult;
83325 }
83326
83327
83328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83329   int jresult ;
83330   int result;
83331
83332   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83333   jresult = (int)result;
83334   return jresult;
83335 }
83336
83337
83338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83339   int jresult ;
83340   int result;
83341
83342   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83343   jresult = (int)result;
83344   return jresult;
83345 }
83346
83347
83348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83349   int jresult ;
83350   int result;
83351
83352   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83353   jresult = (int)result;
83354   return jresult;
83355 }
83356
83357
83358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83359   int jresult ;
83360   int result;
83361
83362   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83363   jresult = (int)result;
83364   return jresult;
83365 }
83366
83367
83368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83369   int jresult ;
83370   int result;
83371
83372   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83373   jresult = (int)result;
83374   return jresult;
83375 }
83376
83377
83378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83379   int jresult ;
83380   int result;
83381
83382   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83383   jresult = (int)result;
83384   return jresult;
83385 }
83386
83387
83388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83389   int jresult ;
83390   int result;
83391
83392   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83393   jresult = (int)result;
83394   return jresult;
83395 }
83396
83397
83398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83399   void * jresult ;
83400   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83401
83402   {
83403     try {
83404       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83405     } catch (std::out_of_range& e) {
83406       {
83407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83408       };
83409     } catch (std::exception& e) {
83410       {
83411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83412       };
83413     } catch (Dali::DaliException e) {
83414       {
83415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83416       };
83417     } catch (...) {
83418       {
83419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83420       };
83421     }
83422   }
83423
83424   jresult = (void *)result;
83425   return jresult;
83426 }
83427
83428
83429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83430   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83431
83432   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83433   {
83434     try {
83435       delete arg1;
83436     } catch (std::out_of_range& e) {
83437       {
83438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83439       };
83440     } catch (std::exception& e) {
83441       {
83442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83443       };
83444     } catch (Dali::DaliException e) {
83445       {
83446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83447       };
83448     } catch (...) {
83449       {
83450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83451       };
83452     }
83453   }
83454
83455 }
83456
83457
83458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83459   void * jresult ;
83460   Dali::Toolkit::ProgressBar result;
83461
83462   {
83463     try {
83464       result = Dali::Toolkit::ProgressBar::New();
83465     } catch (std::out_of_range& e) {
83466       {
83467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83468       };
83469     } catch (std::exception& e) {
83470       {
83471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83472       };
83473     } catch (Dali::DaliException e) {
83474       {
83475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83476       };
83477     } catch (...) {
83478       {
83479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83480       };
83481     }
83482   }
83483
83484   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83485   return jresult;
83486 }
83487
83488
83489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83490   void * jresult ;
83491   Dali::Toolkit::ProgressBar *result = 0 ;
83492
83493   {
83494     try {
83495       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83496     } catch (std::out_of_range& e) {
83497       {
83498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83499       };
83500     } catch (std::exception& e) {
83501       {
83502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83503       };
83504     } catch (Dali::DaliException e) {
83505       {
83506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83507       };
83508     } catch (...) {
83509       {
83510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83511       };
83512     }
83513   }
83514
83515   jresult = (void *)result;
83516   return jresult;
83517 }
83518
83519
83520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83521   void * jresult ;
83522   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83523   Dali::Toolkit::ProgressBar *result = 0 ;
83524
83525   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83526   if (!arg1) {
83527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83528     return 0;
83529   }
83530   {
83531     try {
83532       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83533     } catch (std::out_of_range& e) {
83534       {
83535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83536       };
83537     } catch (std::exception& e) {
83538       {
83539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83540       };
83541     } catch (Dali::DaliException e) {
83542       {
83543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83544       };
83545     } catch (...) {
83546       {
83547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83548       };
83549     }
83550   }
83551
83552   jresult = (void *)result;
83553   return jresult;
83554 }
83555
83556
83557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83558   void * jresult ;
83559   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83560   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83561   Dali::Toolkit::ProgressBar *result = 0 ;
83562
83563   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83564   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83565   if (!arg2) {
83566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83567     return 0;
83568   }
83569   {
83570     try {
83571       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83572     } catch (std::out_of_range& e) {
83573       {
83574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83575       };
83576     } catch (std::exception& e) {
83577       {
83578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83579       };
83580     } catch (Dali::DaliException e) {
83581       {
83582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83583       };
83584     } catch (...) {
83585       {
83586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83587       };
83588     }
83589   }
83590
83591   jresult = (void *)result;
83592   return jresult;
83593 }
83594
83595
83596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83597   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83598
83599   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83600   {
83601     try {
83602       delete arg1;
83603     } catch (std::out_of_range& e) {
83604       {
83605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83606       };
83607     } catch (std::exception& e) {
83608       {
83609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83610       };
83611     } catch (Dali::DaliException e) {
83612       {
83613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83614       };
83615     } catch (...) {
83616       {
83617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83618       };
83619     }
83620   }
83621
83622 }
83623
83624
83625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83626   void * jresult ;
83627   Dali::BaseHandle arg1 ;
83628   Dali::BaseHandle *argp1 ;
83629   Dali::Toolkit::ProgressBar result;
83630
83631   argp1 = (Dali::BaseHandle *)jarg1;
83632   if (!argp1) {
83633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83634     return 0;
83635   }
83636   arg1 = *argp1;
83637   {
83638     try {
83639       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83640     } catch (std::out_of_range& e) {
83641       {
83642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83643       };
83644     } catch (std::exception& e) {
83645       {
83646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83647       };
83648     } catch (Dali::DaliException e) {
83649       {
83650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83651       };
83652     } catch (...) {
83653       {
83654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83655       };
83656     }
83657   }
83658
83659   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83660   return jresult;
83661 }
83662
83663
83664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83665   void * jresult ;
83666   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83667   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83668
83669   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83670   {
83671     try {
83672       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83673     } catch (std::out_of_range& e) {
83674       {
83675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83676       };
83677     } catch (std::exception& e) {
83678       {
83679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83680       };
83681     } catch (Dali::DaliException e) {
83682       {
83683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83684       };
83685     } catch (...) {
83686       {
83687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83688       };
83689     }
83690   }
83691
83692   jresult = (void *)result;
83693   return jresult;
83694 }
83695
83696
83697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83698   void * jresult ;
83699   Dali::Toolkit::GaussianBlurView *result = 0 ;
83700
83701   {
83702     try {
83703       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83704     } catch (std::out_of_range& e) {
83705       {
83706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83707       };
83708     } catch (std::exception& e) {
83709       {
83710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83711       };
83712     } catch (Dali::DaliException e) {
83713       {
83714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83715       };
83716     } catch (...) {
83717       {
83718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83719       };
83720     }
83721   }
83722
83723   jresult = (void *)result;
83724   return jresult;
83725 }
83726
83727
83728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83729   void * jresult ;
83730   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83731   Dali::Toolkit::GaussianBlurView *result = 0 ;
83732
83733   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83734   if (!arg1) {
83735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83736     return 0;
83737   }
83738   {
83739     try {
83740       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83741     } catch (std::out_of_range& e) {
83742       {
83743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83744       };
83745     } catch (std::exception& e) {
83746       {
83747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83748       };
83749     } catch (Dali::DaliException e) {
83750       {
83751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83752       };
83753     } catch (...) {
83754       {
83755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83756       };
83757     }
83758   }
83759
83760   jresult = (void *)result;
83761   return jresult;
83762 }
83763
83764
83765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83766   void * jresult ;
83767   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83768   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83769   Dali::Toolkit::GaussianBlurView *result = 0 ;
83770
83771   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83772   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83773   if (!arg2) {
83774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83775     return 0;
83776   }
83777   {
83778     try {
83779       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
83780     } catch (std::out_of_range& e) {
83781       {
83782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83783       };
83784     } catch (std::exception& e) {
83785       {
83786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83787       };
83788     } catch (Dali::DaliException e) {
83789       {
83790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83791       };
83792     } catch (...) {
83793       {
83794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83795       };
83796     }
83797   }
83798
83799   jresult = (void *)result;
83800   return jresult;
83801 }
83802
83803
83804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
83805   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83806
83807   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83808   {
83809     try {
83810       delete arg1;
83811     } catch (std::out_of_range& e) {
83812       {
83813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83814       };
83815     } catch (std::exception& e) {
83816       {
83817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83818       };
83819     } catch (Dali::DaliException e) {
83820       {
83821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83822       };
83823     } catch (...) {
83824       {
83825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83826       };
83827     }
83828   }
83829
83830 }
83831
83832
83833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
83834   void * jresult ;
83835   Dali::BaseHandle arg1 ;
83836   Dali::BaseHandle *argp1 ;
83837   Dali::Toolkit::GaussianBlurView result;
83838
83839   argp1 = (Dali::BaseHandle *)jarg1;
83840   if (!argp1) {
83841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83842     return 0;
83843   }
83844   arg1 = *argp1;
83845   {
83846     try {
83847       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83848     } catch (std::out_of_range& e) {
83849       {
83850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83851       };
83852     } catch (std::exception& e) {
83853       {
83854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83855       };
83856     } catch (Dali::DaliException e) {
83857       {
83858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83859       };
83860     } catch (...) {
83861       {
83862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83863       };
83864     }
83865   }
83866
83867   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83868   return jresult;
83869 }
83870
83871
83872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
83873   void * jresult ;
83874   Dali::Toolkit::GaussianBlurView result;
83875
83876   {
83877     try {
83878       result = Dali::Toolkit::GaussianBlurView::New();
83879     } catch (std::out_of_range& e) {
83880       {
83881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83882       };
83883     } catch (std::exception& e) {
83884       {
83885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83886       };
83887     } catch (Dali::DaliException e) {
83888       {
83889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83890       };
83891     } catch (...) {
83892       {
83893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83894       };
83895     }
83896   }
83897
83898   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83899   return jresult;
83900 }
83901
83902
83903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
83904   void * jresult ;
83905   unsigned int arg1 ;
83906   float arg2 ;
83907   Dali::Pixel::Format arg3 ;
83908   float arg4 ;
83909   float arg5 ;
83910   bool arg6 ;
83911   Dali::Toolkit::GaussianBlurView result;
83912
83913   arg1 = (unsigned int)jarg1;
83914   arg2 = (float)jarg2;
83915   arg3 = (Dali::Pixel::Format)jarg3;
83916   arg4 = (float)jarg4;
83917   arg5 = (float)jarg5;
83918   arg6 = jarg6 ? true : false;
83919   {
83920     try {
83921       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
83922     } catch (std::out_of_range& e) {
83923       {
83924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83925       };
83926     } catch (std::exception& e) {
83927       {
83928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83929       };
83930     } catch (Dali::DaliException e) {
83931       {
83932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83933       };
83934     } catch (...) {
83935       {
83936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83937       };
83938     }
83939   }
83940
83941   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83942   return jresult;
83943 }
83944
83945
83946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
83947   void * jresult ;
83948   unsigned int arg1 ;
83949   float arg2 ;
83950   Dali::Pixel::Format arg3 ;
83951   float arg4 ;
83952   float arg5 ;
83953   Dali::Toolkit::GaussianBlurView result;
83954
83955   arg1 = (unsigned int)jarg1;
83956   arg2 = (float)jarg2;
83957   arg3 = (Dali::Pixel::Format)jarg3;
83958   arg4 = (float)jarg4;
83959   arg5 = (float)jarg5;
83960   {
83961     try {
83962       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
83963     } catch (std::out_of_range& e) {
83964       {
83965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83966       };
83967     } catch (std::exception& e) {
83968       {
83969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83970       };
83971     } catch (Dali::DaliException e) {
83972       {
83973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83974       };
83975     } catch (...) {
83976       {
83977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83978       };
83979     }
83980   }
83981
83982   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83983   return jresult;
83984 }
83985
83986
83987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
83988   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83989   Dali::Actor arg2 ;
83990   Dali::Actor *argp2 ;
83991
83992   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83993   argp2 = (Dali::Actor *)jarg2;
83994   if (!argp2) {
83995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83996     return ;
83997   }
83998   arg2 = *argp2;
83999   {
84000     try {
84001       (arg1)->Add(arg2);
84002     } catch (std::out_of_range& e) {
84003       {
84004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84005       };
84006     } catch (std::exception& e) {
84007       {
84008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84009       };
84010     } catch (Dali::DaliException e) {
84011       {
84012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84013       };
84014     } catch (...) {
84015       {
84016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84017       };
84018     }
84019   }
84020
84021 }
84022
84023
84024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
84025   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84026   Dali::Actor arg2 ;
84027   Dali::Actor *argp2 ;
84028
84029   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84030   argp2 = (Dali::Actor *)jarg2;
84031   if (!argp2) {
84032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84033     return ;
84034   }
84035   arg2 = *argp2;
84036   {
84037     try {
84038       (arg1)->Remove(arg2);
84039     } catch (std::out_of_range& e) {
84040       {
84041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84042       };
84043     } catch (std::exception& e) {
84044       {
84045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84046       };
84047     } catch (Dali::DaliException e) {
84048       {
84049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84050       };
84051     } catch (...) {
84052       {
84053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84054       };
84055     }
84056   }
84057
84058 }
84059
84060
84061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
84062   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84063
84064   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84065   {
84066     try {
84067       (arg1)->Activate();
84068     } catch (std::out_of_range& e) {
84069       {
84070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84071       };
84072     } catch (std::exception& e) {
84073       {
84074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84075       };
84076     } catch (Dali::DaliException e) {
84077       {
84078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84079       };
84080     } catch (...) {
84081       {
84082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84083       };
84084     }
84085   }
84086
84087 }
84088
84089
84090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
84091   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84092
84093   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84094   {
84095     try {
84096       (arg1)->ActivateOnce();
84097     } catch (std::out_of_range& e) {
84098       {
84099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84100       };
84101     } catch (std::exception& e) {
84102       {
84103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84104       };
84105     } catch (Dali::DaliException e) {
84106       {
84107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84108       };
84109     } catch (...) {
84110       {
84111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84112       };
84113     }
84114   }
84115
84116 }
84117
84118
84119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84120   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84121
84122   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84123   {
84124     try {
84125       (arg1)->Deactivate();
84126     } catch (std::out_of_range& e) {
84127       {
84128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84129       };
84130     } catch (std::exception& e) {
84131       {
84132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84133       };
84134     } catch (Dali::DaliException e) {
84135       {
84136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84137       };
84138     } catch (...) {
84139       {
84140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84141       };
84142     }
84143   }
84144
84145 }
84146
84147
84148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84149   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84150   Dali::Texture arg2 ;
84151   Dali::FrameBuffer arg3 ;
84152   Dali::Texture *argp2 ;
84153   Dali::FrameBuffer *argp3 ;
84154
84155   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84156   argp2 = (Dali::Texture *)jarg2;
84157   if (!argp2) {
84158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
84159     return ;
84160   }
84161   arg2 = *argp2;
84162   argp3 = (Dali::FrameBuffer *)jarg3;
84163   if (!argp3) {
84164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
84165     return ;
84166   }
84167   arg3 = *argp3;
84168   {
84169     try {
84170       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
84171     } catch (std::out_of_range& e) {
84172       {
84173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84174       };
84175     } catch (std::exception& e) {
84176       {
84177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84178       };
84179     } catch (Dali::DaliException e) {
84180       {
84181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84182       };
84183     } catch (...) {
84184       {
84185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84186       };
84187     }
84188   }
84189
84190 }
84191
84192
84193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84194   int jresult ;
84195   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84196   Dali::Property::Index result;
84197
84198   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84199   {
84200     try {
84201       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84202     } catch (std::out_of_range& e) {
84203       {
84204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84205       };
84206     } catch (std::exception& e) {
84207       {
84208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84209       };
84210     } catch (Dali::DaliException e) {
84211       {
84212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84213       };
84214     } catch (...) {
84215       {
84216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84217       };
84218     }
84219   }
84220
84221   jresult = result;
84222   return jresult;
84223 }
84224
84225
84226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84227   void * jresult ;
84228   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84229   Dali::FrameBuffer result;
84230
84231   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84232   {
84233     try {
84234       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84235     } catch (std::out_of_range& e) {
84236       {
84237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84238       };
84239     } catch (std::exception& e) {
84240       {
84241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84242       };
84243     } catch (Dali::DaliException e) {
84244       {
84245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84246       };
84247     } catch (...) {
84248       {
84249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84250       };
84251     }
84252   }
84253
84254   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
84255   return jresult;
84256 }
84257
84258
84259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84260   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84261   Dali::Vector4 *arg2 = 0 ;
84262
84263   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84264   arg2 = (Dali::Vector4 *)jarg2;
84265   if (!arg2) {
84266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84267     return ;
84268   }
84269   {
84270     try {
84271       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84272     } catch (std::out_of_range& e) {
84273       {
84274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84275       };
84276     } catch (std::exception& e) {
84277       {
84278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84279       };
84280     } catch (Dali::DaliException e) {
84281       {
84282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84283       };
84284     } catch (...) {
84285       {
84286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84287       };
84288     }
84289   }
84290
84291 }
84292
84293
84294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84295   void * jresult ;
84296   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84297   Dali::Vector4 result;
84298
84299   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84300   {
84301     try {
84302       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84303     } catch (std::out_of_range& e) {
84304       {
84305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84306       };
84307     } catch (std::exception& e) {
84308       {
84309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84310       };
84311     } catch (Dali::DaliException e) {
84312       {
84313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84314       };
84315     } catch (...) {
84316       {
84317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84318       };
84319     }
84320   }
84321
84322   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84323   return jresult;
84324 }
84325
84326
84327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84328   void * jresult ;
84329   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84330   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84331
84332   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84333   {
84334     try {
84335       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84336     } catch (std::out_of_range& e) {
84337       {
84338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84339       };
84340     } catch (std::exception& e) {
84341       {
84342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84343       };
84344     } catch (Dali::DaliException e) {
84345       {
84346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84347       };
84348     } catch (...) {
84349       {
84350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84351       };
84352     }
84353   }
84354
84355   jresult = (void *)result;
84356   return jresult;
84357 }
84358
84359
84360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84361   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84362
84363   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84364   {
84365     try {
84366       delete arg1;
84367     } catch (std::out_of_range& e) {
84368       {
84369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84370       };
84371     } catch (std::exception& e) {
84372       {
84373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84374       };
84375     } catch (Dali::DaliException e) {
84376       {
84377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84378       };
84379     } catch (...) {
84380       {
84381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84382       };
84383     }
84384   }
84385
84386 }
84387
84388
84389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84390   unsigned int jresult ;
84391   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84392   unsigned int result;
84393
84394   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84395   {
84396     try {
84397       result = (unsigned int)(arg1)->GetNumberOfPages();
84398     } catch (std::out_of_range& e) {
84399       {
84400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84401       };
84402     } catch (std::exception& e) {
84403       {
84404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84405       };
84406     } catch (Dali::DaliException e) {
84407       {
84408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84409       };
84410     } catch (...) {
84411       {
84412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84413       };
84414     }
84415   }
84416
84417   jresult = result;
84418   return jresult;
84419 }
84420
84421
84422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84423   void * jresult ;
84424   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84425   unsigned int arg2 ;
84426   Dali::Texture result;
84427
84428   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84429   arg2 = (unsigned int)jarg2;
84430   {
84431     try {
84432       result = (arg1)->NewPage(arg2);
84433     } catch (std::out_of_range& e) {
84434       {
84435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84436       };
84437     } catch (std::exception& e) {
84438       {
84439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84440       };
84441     } catch (Dali::DaliException e) {
84442       {
84443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84444       };
84445     } catch (...) {
84446       {
84447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84448       };
84449     }
84450   }
84451
84452   jresult = new Dali::Texture((const Dali::Texture &)result);
84453   return jresult;
84454 }
84455
84456
84457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
84458   int jresult ;
84459   int result;
84460
84461   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
84462   jresult = (int)result;
84463   return jresult;
84464 }
84465
84466
84467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84468   int jresult ;
84469   int result;
84470
84471   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84472   jresult = (int)result;
84473   return jresult;
84474 }
84475
84476
84477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84478   int jresult ;
84479   int result;
84480
84481   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84482   jresult = (int)result;
84483   return jresult;
84484 }
84485
84486
84487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84488   void * jresult ;
84489   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84490
84491   {
84492     try {
84493       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84494     } catch (std::out_of_range& e) {
84495       {
84496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84497       };
84498     } catch (std::exception& e) {
84499       {
84500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84501       };
84502     } catch (Dali::DaliException e) {
84503       {
84504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84505       };
84506     } catch (...) {
84507       {
84508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84509       };
84510     }
84511   }
84512
84513   jresult = (void *)result;
84514   return jresult;
84515 }
84516
84517
84518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84519   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84520
84521   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84522   {
84523     try {
84524       delete arg1;
84525     } catch (std::out_of_range& e) {
84526       {
84527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84528       };
84529     } catch (std::exception& e) {
84530       {
84531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84532       };
84533     } catch (Dali::DaliException e) {
84534       {
84535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84536       };
84537     } catch (...) {
84538       {
84539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84540       };
84541     }
84542   }
84543
84544 }
84545
84546
84547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84548   void * jresult ;
84549   Dali::Toolkit::PageTurnView *result = 0 ;
84550
84551   {
84552     try {
84553       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84554     } catch (std::out_of_range& e) {
84555       {
84556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84557       };
84558     } catch (std::exception& e) {
84559       {
84560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84561       };
84562     } catch (Dali::DaliException e) {
84563       {
84564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84565       };
84566     } catch (...) {
84567       {
84568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84569       };
84570     }
84571   }
84572
84573   jresult = (void *)result;
84574   return jresult;
84575 }
84576
84577
84578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84579   void * jresult ;
84580   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84581   Dali::Toolkit::PageTurnView *result = 0 ;
84582
84583   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84584   if (!arg1) {
84585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84586     return 0;
84587   }
84588   {
84589     try {
84590       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84591     } catch (std::out_of_range& e) {
84592       {
84593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84594       };
84595     } catch (std::exception& e) {
84596       {
84597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84598       };
84599     } catch (Dali::DaliException e) {
84600       {
84601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84602       };
84603     } catch (...) {
84604       {
84605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84606       };
84607     }
84608   }
84609
84610   jresult = (void *)result;
84611   return jresult;
84612 }
84613
84614
84615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84616   void * jresult ;
84617   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84618   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84619   Dali::Toolkit::PageTurnView *result = 0 ;
84620
84621   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84622   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84623   if (!arg2) {
84624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84625     return 0;
84626   }
84627   {
84628     try {
84629       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84630     } catch (std::out_of_range& e) {
84631       {
84632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84633       };
84634     } catch (std::exception& e) {
84635       {
84636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84637       };
84638     } catch (Dali::DaliException e) {
84639       {
84640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84641       };
84642     } catch (...) {
84643       {
84644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84645       };
84646     }
84647   }
84648
84649   jresult = (void *)result;
84650   return jresult;
84651 }
84652
84653
84654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84655   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84656
84657   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84658   {
84659     try {
84660       delete arg1;
84661     } catch (std::out_of_range& e) {
84662       {
84663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84664       };
84665     } catch (std::exception& e) {
84666       {
84667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84668       };
84669     } catch (Dali::DaliException e) {
84670       {
84671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84672       };
84673     } catch (...) {
84674       {
84675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84676       };
84677     }
84678   }
84679
84680 }
84681
84682
84683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84684   void * jresult ;
84685   Dali::BaseHandle arg1 ;
84686   Dali::BaseHandle *argp1 ;
84687   Dali::Toolkit::PageTurnView result;
84688
84689   argp1 = (Dali::BaseHandle *)jarg1;
84690   if (!argp1) {
84691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84692     return 0;
84693   }
84694   arg1 = *argp1;
84695   {
84696     try {
84697       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84698     } catch (std::out_of_range& e) {
84699       {
84700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84701       };
84702     } catch (std::exception& e) {
84703       {
84704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84705       };
84706     } catch (Dali::DaliException e) {
84707       {
84708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84709       };
84710     } catch (...) {
84711       {
84712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84713       };
84714     }
84715   }
84716
84717   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84718   return jresult;
84719 }
84720
84721
84722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84723   void * jresult ;
84724   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84725   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84726
84727   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84728   {
84729     try {
84730       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84731     } catch (std::out_of_range& e) {
84732       {
84733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84734       };
84735     } catch (std::exception& e) {
84736       {
84737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84738       };
84739     } catch (Dali::DaliException e) {
84740       {
84741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84742       };
84743     } catch (...) {
84744       {
84745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84746       };
84747     }
84748   }
84749
84750   jresult = (void *)result;
84751   return jresult;
84752 }
84753
84754
84755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84756   void * jresult ;
84757   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84758   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84759
84760   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84761   {
84762     try {
84763       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84764     } catch (std::out_of_range& e) {
84765       {
84766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84767       };
84768     } catch (std::exception& e) {
84769       {
84770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84771       };
84772     } catch (Dali::DaliException e) {
84773       {
84774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84775       };
84776     } catch (...) {
84777       {
84778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84779       };
84780     }
84781   }
84782
84783   jresult = (void *)result;
84784   return jresult;
84785 }
84786
84787
84788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
84789   void * jresult ;
84790   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84791   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84792
84793   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84794   {
84795     try {
84796       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84797     } catch (std::out_of_range& e) {
84798       {
84799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84800       };
84801     } catch (std::exception& e) {
84802       {
84803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84804       };
84805     } catch (Dali::DaliException e) {
84806       {
84807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84808       };
84809     } catch (...) {
84810       {
84811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84812       };
84813     }
84814   }
84815
84816   jresult = (void *)result;
84817   return jresult;
84818 }
84819
84820
84821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84822   void * jresult ;
84823   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84824   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84825
84826   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84827   {
84828     try {
84829       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84830     } catch (std::out_of_range& e) {
84831       {
84832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84833       };
84834     } catch (std::exception& e) {
84835       {
84836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84837       };
84838     } catch (Dali::DaliException e) {
84839       {
84840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84841       };
84842     } catch (...) {
84843       {
84844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84845       };
84846     }
84847   }
84848
84849   jresult = (void *)result;
84850   return jresult;
84851 }
84852
84853
84854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
84855   void * jresult ;
84856   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84857
84858   {
84859     try {
84860       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84861     } catch (std::out_of_range& e) {
84862       {
84863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84864       };
84865     } catch (std::exception& e) {
84866       {
84867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84868       };
84869     } catch (Dali::DaliException e) {
84870       {
84871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84872       };
84873     } catch (...) {
84874       {
84875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84876       };
84877     }
84878   }
84879
84880   jresult = (void *)result;
84881   return jresult;
84882 }
84883
84884
84885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84886   void * jresult ;
84887   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84888   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84889
84890   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84891   if (!arg1) {
84892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84893     return 0;
84894   }
84895   {
84896     try {
84897       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
84898     } catch (std::out_of_range& e) {
84899       {
84900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84901       };
84902     } catch (std::exception& e) {
84903       {
84904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84905       };
84906     } catch (Dali::DaliException e) {
84907       {
84908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84909       };
84910     } catch (...) {
84911       {
84912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84913       };
84914     }
84915   }
84916
84917   jresult = (void *)result;
84918   return jresult;
84919 }
84920
84921
84922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
84923   void * jresult ;
84924   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84925   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
84926   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84927
84928   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84929   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
84930   if (!arg2) {
84931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84932     return 0;
84933   }
84934   {
84935     try {
84936       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
84937     } catch (std::out_of_range& e) {
84938       {
84939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84940       };
84941     } catch (std::exception& e) {
84942       {
84943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84944       };
84945     } catch (Dali::DaliException e) {
84946       {
84947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84948       };
84949     } catch (...) {
84950       {
84951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84952       };
84953     }
84954   }
84955
84956   jresult = (void *)result;
84957   return jresult;
84958 }
84959
84960
84961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
84962   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84963
84964   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84965   {
84966     try {
84967       delete arg1;
84968     } catch (std::out_of_range& e) {
84969       {
84970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84971       };
84972     } catch (std::exception& e) {
84973       {
84974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84975       };
84976     } catch (Dali::DaliException e) {
84977       {
84978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84979       };
84980     } catch (...) {
84981       {
84982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84983       };
84984     }
84985   }
84986
84987 }
84988
84989
84990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
84991   void * jresult ;
84992   Dali::Toolkit::PageFactory *arg1 = 0 ;
84993   Dali::Vector2 *arg2 = 0 ;
84994   Dali::Toolkit::PageTurnLandscapeView result;
84995
84996   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84997   if (!arg1) {
84998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84999     return 0;
85000   }
85001   arg2 = (Dali::Vector2 *)jarg2;
85002   if (!arg2) {
85003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85004     return 0;
85005   }
85006   {
85007     try {
85008       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
85009     } catch (std::out_of_range& e) {
85010       {
85011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85012       };
85013     } catch (std::exception& e) {
85014       {
85015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85016       };
85017     } catch (Dali::DaliException e) {
85018       {
85019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85020       };
85021     } catch (...) {
85022       {
85023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85024       };
85025     }
85026   }
85027
85028   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85029   return jresult;
85030 }
85031
85032
85033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
85034   void * jresult ;
85035   Dali::BaseHandle arg1 ;
85036   Dali::BaseHandle *argp1 ;
85037   Dali::Toolkit::PageTurnLandscapeView result;
85038
85039   argp1 = (Dali::BaseHandle *)jarg1;
85040   if (!argp1) {
85041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85042     return 0;
85043   }
85044   arg1 = *argp1;
85045   {
85046     try {
85047       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
85048     } catch (std::out_of_range& e) {
85049       {
85050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85051       };
85052     } catch (std::exception& e) {
85053       {
85054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85055       };
85056     } catch (Dali::DaliException e) {
85057       {
85058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85059       };
85060     } catch (...) {
85061       {
85062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85063       };
85064     }
85065   }
85066
85067   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85068   return jresult;
85069 }
85070
85071
85072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
85073   void * jresult ;
85074   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85075
85076   {
85077     try {
85078       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
85079     } catch (std::out_of_range& e) {
85080       {
85081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85082       };
85083     } catch (std::exception& e) {
85084       {
85085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85086       };
85087     } catch (Dali::DaliException e) {
85088       {
85089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85090       };
85091     } catch (...) {
85092       {
85093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85094       };
85095     }
85096   }
85097
85098   jresult = (void *)result;
85099   return jresult;
85100 }
85101
85102
85103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
85104   void * jresult ;
85105   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
85106   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85107
85108   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85109   if (!arg1) {
85110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85111     return 0;
85112   }
85113   {
85114     try {
85115       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
85116     } catch (std::out_of_range& e) {
85117       {
85118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85119       };
85120     } catch (std::exception& e) {
85121       {
85122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85123       };
85124     } catch (Dali::DaliException e) {
85125       {
85126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85127       };
85128     } catch (...) {
85129       {
85130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85131       };
85132     }
85133   }
85134
85135   jresult = (void *)result;
85136   return jresult;
85137 }
85138
85139
85140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
85141   void * jresult ;
85142   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85143   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
85144   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85145
85146   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85147   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
85148   if (!arg2) {
85149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85150     return 0;
85151   }
85152   {
85153     try {
85154       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
85155     } catch (std::out_of_range& e) {
85156       {
85157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85158       };
85159     } catch (std::exception& e) {
85160       {
85161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85162       };
85163     } catch (Dali::DaliException e) {
85164       {
85165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85166       };
85167     } catch (...) {
85168       {
85169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85170       };
85171     }
85172   }
85173
85174   jresult = (void *)result;
85175   return jresult;
85176 }
85177
85178
85179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
85180   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85181
85182   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85183   {
85184     try {
85185       delete arg1;
85186     } catch (std::out_of_range& e) {
85187       {
85188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85189       };
85190     } catch (std::exception& e) {
85191       {
85192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85193       };
85194     } catch (Dali::DaliException e) {
85195       {
85196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85197       };
85198     } catch (...) {
85199       {
85200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85201       };
85202     }
85203   }
85204
85205 }
85206
85207
85208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
85209   void * jresult ;
85210   Dali::Toolkit::PageFactory *arg1 = 0 ;
85211   Dali::Vector2 *arg2 = 0 ;
85212   Dali::Toolkit::PageTurnPortraitView result;
85213
85214   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85215   if (!arg1) {
85216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85217     return 0;
85218   }
85219   arg2 = (Dali::Vector2 *)jarg2;
85220   if (!arg2) {
85221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85222     return 0;
85223   }
85224   {
85225     try {
85226       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85227     } catch (std::out_of_range& e) {
85228       {
85229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85230       };
85231     } catch (std::exception& e) {
85232       {
85233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85234       };
85235     } catch (Dali::DaliException e) {
85236       {
85237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85238       };
85239     } catch (...) {
85240       {
85241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85242       };
85243     }
85244   }
85245
85246   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85247   return jresult;
85248 }
85249
85250
85251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85252   void * jresult ;
85253   Dali::BaseHandle arg1 ;
85254   Dali::BaseHandle *argp1 ;
85255   Dali::Toolkit::PageTurnPortraitView result;
85256
85257   argp1 = (Dali::BaseHandle *)jarg1;
85258   if (!argp1) {
85259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85260     return 0;
85261   }
85262   arg1 = *argp1;
85263   {
85264     try {
85265       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85266     } catch (std::out_of_range& e) {
85267       {
85268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85269       };
85270     } catch (std::exception& e) {
85271       {
85272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85273       };
85274     } catch (Dali::DaliException e) {
85275       {
85276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85277       };
85278     } catch (...) {
85279       {
85280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85281       };
85282     }
85283   }
85284
85285   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85286   return jresult;
85287 }
85288
85289
85290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85291   int jresult ;
85292   int result;
85293
85294   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85295   jresult = (int)result;
85296   return jresult;
85297 }
85298
85299
85300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85301   int jresult ;
85302   int result;
85303
85304   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85305   jresult = (int)result;
85306   return jresult;
85307 }
85308
85309
85310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85311   int jresult ;
85312   int result;
85313
85314   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85315   jresult = (int)result;
85316   return jresult;
85317 }
85318
85319
85320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85321   void * jresult ;
85322   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85323
85324   {
85325     try {
85326       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85327     } catch (std::out_of_range& e) {
85328       {
85329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85330       };
85331     } catch (std::exception& e) {
85332       {
85333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85334       };
85335     } catch (Dali::DaliException e) {
85336       {
85337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85338       };
85339     } catch (...) {
85340       {
85341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85342       };
85343     }
85344   }
85345
85346   jresult = (void *)result;
85347   return jresult;
85348 }
85349
85350
85351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85352   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85353
85354   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85355   {
85356     try {
85357       delete arg1;
85358     } catch (std::out_of_range& e) {
85359       {
85360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85361       };
85362     } catch (std::exception& e) {
85363       {
85364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85365       };
85366     } catch (Dali::DaliException e) {
85367       {
85368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85369       };
85370     } catch (...) {
85371       {
85372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85373       };
85374     }
85375   }
85376
85377 }
85378
85379
85380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85381   void * jresult ;
85382   Dali::Toolkit::ToggleButton *result = 0 ;
85383
85384   {
85385     try {
85386       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85387     } catch (std::out_of_range& e) {
85388       {
85389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85390       };
85391     } catch (std::exception& e) {
85392       {
85393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85394       };
85395     } catch (Dali::DaliException e) {
85396       {
85397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85398       };
85399     } catch (...) {
85400       {
85401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85402       };
85403     }
85404   }
85405
85406   jresult = (void *)result;
85407   return jresult;
85408 }
85409
85410
85411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85412   void * jresult ;
85413   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85414   Dali::Toolkit::ToggleButton *result = 0 ;
85415
85416   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85417   if (!arg1) {
85418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85419     return 0;
85420   }
85421   {
85422     try {
85423       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85424     } catch (std::out_of_range& e) {
85425       {
85426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85427       };
85428     } catch (std::exception& e) {
85429       {
85430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85431       };
85432     } catch (Dali::DaliException e) {
85433       {
85434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85435       };
85436     } catch (...) {
85437       {
85438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85439       };
85440     }
85441   }
85442
85443   jresult = (void *)result;
85444   return jresult;
85445 }
85446
85447
85448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85449   void * jresult ;
85450   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85451   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85452   Dali::Toolkit::ToggleButton *result = 0 ;
85453
85454   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85455   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85456   if (!arg2) {
85457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85458     return 0;
85459   }
85460   {
85461     try {
85462       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85463     } catch (std::out_of_range& e) {
85464       {
85465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85466       };
85467     } catch (std::exception& e) {
85468       {
85469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85470       };
85471     } catch (Dali::DaliException e) {
85472       {
85473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85474       };
85475     } catch (...) {
85476       {
85477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85478       };
85479     }
85480   }
85481
85482   jresult = (void *)result;
85483   return jresult;
85484 }
85485
85486
85487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85488   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85489
85490   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85491   {
85492     try {
85493       delete arg1;
85494     } catch (std::out_of_range& e) {
85495       {
85496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85497       };
85498     } catch (std::exception& e) {
85499       {
85500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85501       };
85502     } catch (Dali::DaliException e) {
85503       {
85504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85505       };
85506     } catch (...) {
85507       {
85508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85509       };
85510     }
85511   }
85512
85513 }
85514
85515
85516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85517   void * jresult ;
85518   Dali::Toolkit::ToggleButton result;
85519
85520   {
85521     try {
85522       result = Dali::Toolkit::ToggleButton::New();
85523     } catch (std::out_of_range& e) {
85524       {
85525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85526       };
85527     } catch (std::exception& e) {
85528       {
85529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85530       };
85531     } catch (Dali::DaliException e) {
85532       {
85533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85534       };
85535     } catch (...) {
85536       {
85537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85538       };
85539     }
85540   }
85541
85542   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85543   return jresult;
85544 }
85545
85546
85547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85548   void * jresult ;
85549   Dali::BaseHandle arg1 ;
85550   Dali::BaseHandle *argp1 ;
85551   Dali::Toolkit::ToggleButton result;
85552
85553   argp1 = (Dali::BaseHandle *)jarg1;
85554   if (!argp1) {
85555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85556     return 0;
85557   }
85558   arg1 = *argp1;
85559   {
85560     try {
85561       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
85562     } catch (std::out_of_range& e) {
85563       {
85564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85565       };
85566     } catch (std::exception& e) {
85567       {
85568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85569       };
85570     } catch (Dali::DaliException e) {
85571       {
85572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85573       };
85574     } catch (...) {
85575       {
85576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85577       };
85578     }
85579   }
85580
85581   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85582   return jresult;
85583 }
85584
85585
85586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85587   void * jresult ;
85588   Dali::Toolkit::Visual::Base *result = 0 ;
85589
85590   {
85591     try {
85592       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85593     } catch (std::out_of_range& e) {
85594       {
85595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85596       };
85597     } catch (std::exception& e) {
85598       {
85599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85600       };
85601     } catch (Dali::DaliException e) {
85602       {
85603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85604       };
85605     } catch (...) {
85606       {
85607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85608       };
85609     }
85610   }
85611
85612   jresult = (void *)result;
85613   return jresult;
85614 }
85615
85616
85617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85618   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85619
85620   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85621   {
85622     try {
85623       delete arg1;
85624     } catch (std::out_of_range& e) {
85625       {
85626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85627       };
85628     } catch (std::exception& e) {
85629       {
85630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85631       };
85632     } catch (Dali::DaliException e) {
85633       {
85634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85635       };
85636     } catch (...) {
85637       {
85638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85639       };
85640     }
85641   }
85642
85643 }
85644
85645
85646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85647   void * jresult ;
85648   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85649   Dali::Toolkit::Visual::Base *result = 0 ;
85650
85651   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85652   if (!arg1) {
85653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85654     return 0;
85655   }
85656   {
85657     try {
85658       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85659     } catch (std::out_of_range& e) {
85660       {
85661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85662       };
85663     } catch (std::exception& e) {
85664       {
85665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85666       };
85667     } catch (Dali::DaliException e) {
85668       {
85669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85670       };
85671     } catch (...) {
85672       {
85673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85674       };
85675     }
85676   }
85677
85678   jresult = (void *)result;
85679   return jresult;
85680 }
85681
85682
85683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85684   void * jresult ;
85685   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85686   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85687   Dali::Toolkit::Visual::Base *result = 0 ;
85688
85689   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85690   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85691   if (!arg2) {
85692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85693     return 0;
85694   }
85695   {
85696     try {
85697       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
85698     } catch (std::out_of_range& e) {
85699       {
85700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85701       };
85702     } catch (std::exception& e) {
85703       {
85704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85705       };
85706     } catch (Dali::DaliException e) {
85707       {
85708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85709       };
85710     } catch (...) {
85711       {
85712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85713       };
85714     }
85715   }
85716
85717   jresult = (void *)result;
85718   return jresult;
85719 }
85720
85721
85722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85723   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85724   std::string *arg2 = 0 ;
85725
85726   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85727   if (!jarg2) {
85728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85729     return ;
85730   }
85731   std::string arg2_str(jarg2);
85732   arg2 = &arg2_str;
85733   {
85734     try {
85735       (arg1)->SetName((std::string const &)*arg2);
85736     } catch (std::out_of_range& e) {
85737       {
85738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85739       };
85740     } catch (std::exception& e) {
85741       {
85742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85743       };
85744     } catch (Dali::DaliException e) {
85745       {
85746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85747       };
85748     } catch (...) {
85749       {
85750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85751       };
85752     }
85753   }
85754
85755
85756   //argout typemap for const std::string&
85757
85758 }
85759
85760
85761 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
85762   char * jresult ;
85763   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85764   std::string *result = 0 ;
85765
85766   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85767   {
85768     try {
85769       result = (std::string *) &(arg1)->GetName();
85770     } catch (std::out_of_range& e) {
85771       {
85772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85773       };
85774     } catch (std::exception& e) {
85775       {
85776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85777       };
85778     } catch (Dali::DaliException e) {
85779       {
85780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85781       };
85782     } catch (...) {
85783       {
85784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85785       };
85786     }
85787   }
85788
85789   jresult = SWIG_csharp_string_callback(result->c_str());
85790   return jresult;
85791 }
85792
85793
85794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
85795   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85796   Dali::Property::Map *arg2 = 0 ;
85797   Dali::Size arg3 ;
85798   Dali::Size *argp3 ;
85799
85800   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85801   arg2 = (Dali::Property::Map *)jarg2;
85802   if (!arg2) {
85803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85804     return ;
85805   }
85806   argp3 = (Dali::Size *)jarg3;
85807   if (!argp3) {
85808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
85809     return ;
85810   }
85811   arg3 = *argp3;
85812   {
85813     try {
85814       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
85815     } catch (std::out_of_range& e) {
85816       {
85817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85818       };
85819     } catch (std::exception& e) {
85820       {
85821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85822       };
85823     } catch (Dali::DaliException e) {
85824       {
85825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85826       };
85827     } catch (...) {
85828       {
85829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85830       };
85831     }
85832   }
85833
85834 }
85835
85836
85837 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
85838   float jresult ;
85839   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85840   float arg2 ;
85841   float result;
85842
85843   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85844   arg2 = (float)jarg2;
85845   {
85846     try {
85847       result = (float)(arg1)->GetHeightForWidth(arg2);
85848     } catch (std::out_of_range& e) {
85849       {
85850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85851       };
85852     } catch (std::exception& e) {
85853       {
85854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85855       };
85856     } catch (Dali::DaliException e) {
85857       {
85858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85859       };
85860     } catch (...) {
85861       {
85862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85863       };
85864     }
85865   }
85866
85867   jresult = result;
85868   return jresult;
85869 }
85870
85871
85872 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
85873   float jresult ;
85874   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85875   float arg2 ;
85876   float result;
85877
85878   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85879   arg2 = (float)jarg2;
85880   {
85881     try {
85882       result = (float)(arg1)->GetWidthForHeight(arg2);
85883     } catch (std::out_of_range& e) {
85884       {
85885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85886       };
85887     } catch (std::exception& e) {
85888       {
85889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85890       };
85891     } catch (Dali::DaliException e) {
85892       {
85893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85894       };
85895     } catch (...) {
85896       {
85897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85898       };
85899     }
85900   }
85901
85902   jresult = result;
85903   return jresult;
85904 }
85905
85906
85907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
85908   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85909   Dali::Vector2 *arg2 = 0 ;
85910
85911   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85912   arg2 = (Dali::Vector2 *)jarg2;
85913   if (!arg2) {
85914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
85915     return ;
85916   }
85917   {
85918     try {
85919       (arg1)->GetNaturalSize(*arg2);
85920     } catch (std::out_of_range& e) {
85921       {
85922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85923       };
85924     } catch (std::exception& e) {
85925       {
85926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85927       };
85928     } catch (Dali::DaliException e) {
85929       {
85930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85931       };
85932     } catch (...) {
85933       {
85934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85935       };
85936     }
85937   }
85938
85939 }
85940
85941
85942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
85943   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85944   float arg2 ;
85945
85946   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85947   arg2 = (int)jarg2;
85948   {
85949     try {
85950       (arg1)->SetDepthIndex(arg2);
85951     } catch (std::out_of_range& e) {
85952       {
85953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85954       };
85955     } catch (std::exception& e) {
85956       {
85957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85958       };
85959     } catch (Dali::DaliException e) {
85960       {
85961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85962       };
85963     } catch (...) {
85964       {
85965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85966       };
85967     }
85968   }
85969
85970 }
85971
85972
85973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
85974   int jresult ;
85975   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85976   int result;
85977
85978   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85979   {
85980     try {
85981       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
85982     } catch (std::out_of_range& e) {
85983       {
85984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85985       };
85986     } catch (std::exception& e) {
85987       {
85988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85989       };
85990     } catch (Dali::DaliException e) {
85991       {
85992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85993       };
85994     } catch (...) {
85995       {
85996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85997       };
85998     }
85999   }
86000
86001   jresult = result;
86002   return jresult;
86003 }
86004
86005
86006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
86007   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86008   Dali::Property::Map *arg2 = 0 ;
86009
86010   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86011   arg2 = (Dali::Property::Map *)jarg2;
86012   if (!arg2) {
86013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
86014     return ;
86015   }
86016   {
86017     try {
86018       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
86019     } catch (std::out_of_range& e) {
86020       {
86021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86022       };
86023     } catch (std::exception& e) {
86024       {
86025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86026       };
86027     } catch (Dali::DaliException e) {
86028       {
86029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86030       };
86031     } catch (...) {
86032       {
86033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86034       };
86035     }
86036   }
86037
86038 }
86039
86040
86041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
86042   void * jresult ;
86043   Dali::Toolkit::VisualFactory result;
86044
86045   {
86046     try {
86047       result = Dali::Toolkit::VisualFactory::Get();
86048     } catch (std::out_of_range& e) {
86049       {
86050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86051       };
86052     } catch (std::exception& e) {
86053       {
86054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86055       };
86056     } catch (Dali::DaliException e) {
86057       {
86058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86059       };
86060     } catch (...) {
86061       {
86062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86063       };
86064     }
86065   }
86066
86067   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
86068   return jresult;
86069 }
86070
86071
86072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
86073   void * jresult ;
86074   Dali::Toolkit::VisualFactory *result = 0 ;
86075
86076   {
86077     try {
86078       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
86079     } catch (std::out_of_range& e) {
86080       {
86081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86082       };
86083     } catch (std::exception& e) {
86084       {
86085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86086       };
86087     } catch (Dali::DaliException e) {
86088       {
86089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86090       };
86091     } catch (...) {
86092       {
86093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86094       };
86095     }
86096   }
86097
86098   jresult = (void *)result;
86099   return jresult;
86100 }
86101
86102
86103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
86104   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86105
86106   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86107   {
86108     try {
86109       delete arg1;
86110     } catch (std::out_of_range& e) {
86111       {
86112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86113       };
86114     } catch (std::exception& e) {
86115       {
86116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86117       };
86118     } catch (Dali::DaliException e) {
86119       {
86120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86121       };
86122     } catch (...) {
86123       {
86124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86125       };
86126     }
86127   }
86128
86129 }
86130
86131
86132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
86133   void * jresult ;
86134   Dali::Toolkit::VisualFactory *arg1 = 0 ;
86135   Dali::Toolkit::VisualFactory *result = 0 ;
86136
86137   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86138   if (!arg1) {
86139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86140     return 0;
86141   }
86142   {
86143     try {
86144       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
86145     } catch (std::out_of_range& e) {
86146       {
86147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86148       };
86149     } catch (std::exception& e) {
86150       {
86151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86152       };
86153     } catch (Dali::DaliException e) {
86154       {
86155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86156       };
86157     } catch (...) {
86158       {
86159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86160       };
86161     }
86162   }
86163
86164   jresult = (void *)result;
86165   return jresult;
86166 }
86167
86168
86169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
86170   void * jresult ;
86171   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86172   Dali::Toolkit::VisualFactory *arg2 = 0 ;
86173   Dali::Toolkit::VisualFactory *result = 0 ;
86174
86175   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86176   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
86177   if (!arg2) {
86178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86179     return 0;
86180   }
86181   {
86182     try {
86183       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
86184     } catch (std::out_of_range& e) {
86185       {
86186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86187       };
86188     } catch (std::exception& e) {
86189       {
86190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86191       };
86192     } catch (Dali::DaliException e) {
86193       {
86194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86195       };
86196     } catch (...) {
86197       {
86198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86199       };
86200     }
86201   }
86202
86203   jresult = (void *)result;
86204   return jresult;
86205 }
86206
86207
86208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
86209   void * jresult ;
86210   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86211   Dali::Property::Map *arg2 = 0 ;
86212   Dali::Toolkit::Visual::Base result;
86213
86214   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86215   arg2 = (Dali::Property::Map *)jarg2;
86216   if (!arg2) {
86217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86218     return 0;
86219   }
86220   {
86221     try {
86222       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
86223     } catch (std::out_of_range& e) {
86224       {
86225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86226       };
86227     } catch (std::exception& e) {
86228       {
86229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86230       };
86231     } catch (Dali::DaliException e) {
86232       {
86233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86234       };
86235     } catch (...) {
86236       {
86237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86238       };
86239     }
86240   }
86241
86242   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86243   return jresult;
86244 }
86245
86246
86247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
86248   void * jresult ;
86249   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86250   std::string *arg2 = 0 ;
86251   Dali::ImageDimensions arg3 ;
86252   Dali::ImageDimensions *argp3 ;
86253   Dali::Toolkit::Visual::Base result;
86254
86255   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86256   if (!jarg2) {
86257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86258     return 0;
86259   }
86260   std::string arg2_str(jarg2);
86261   arg2 = &arg2_str;
86262   argp3 = (Dali::ImageDimensions *)jarg3;
86263   if (!argp3) {
86264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86265     return 0;
86266   }
86267   arg3 = *argp3;
86268   {
86269     try {
86270       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
86271     } catch (std::out_of_range& e) {
86272       {
86273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86274       };
86275     } catch (std::exception& e) {
86276       {
86277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86278       };
86279     } catch (Dali::DaliException e) {
86280       {
86281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86282       };
86283     } catch (...) {
86284       {
86285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86286       };
86287     }
86288   }
86289
86290   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86291
86292   //argout typemap for const std::string&
86293
86294   return jresult;
86295 }
86296
86297
86298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
86299   void * jresult ;
86300   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86301
86302   {
86303     try {
86304       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
86305     } catch (std::out_of_range& e) {
86306       {
86307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86308       };
86309     } catch (std::exception& e) {
86310       {
86311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86312       };
86313     } catch (Dali::DaliException e) {
86314       {
86315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86316       };
86317     } catch (...) {
86318       {
86319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86320       };
86321     }
86322   }
86323
86324   jresult = (void *)result;
86325   return jresult;
86326 }
86327
86328
86329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86330   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86331
86332   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86333   {
86334     try {
86335       delete arg1;
86336     } catch (std::out_of_range& e) {
86337       {
86338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86339       };
86340     } catch (std::exception& e) {
86341       {
86342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86343       };
86344     } catch (Dali::DaliException e) {
86345       {
86346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86347       };
86348     } catch (...) {
86349       {
86350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86351       };
86352     }
86353   }
86354
86355 }
86356
86357
86358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86359   void * jresult ;
86360   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86361   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86362
86363   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86364   if (!arg1) {
86365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86366     return 0;
86367   }
86368   {
86369     try {
86370       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86371     } catch (std::out_of_range& e) {
86372       {
86373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86374       };
86375     } catch (std::exception& e) {
86376       {
86377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86378       };
86379     } catch (Dali::DaliException e) {
86380       {
86381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86382       };
86383     } catch (...) {
86384       {
86385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86386       };
86387     }
86388   }
86389
86390   jresult = (void *)result;
86391   return jresult;
86392 }
86393
86394
86395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86396   void * jresult ;
86397   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86398   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86399   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86400
86401   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86402   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86403   if (!arg2) {
86404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86405     return 0;
86406   }
86407   {
86408     try {
86409       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86410     } catch (std::out_of_range& e) {
86411       {
86412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86413       };
86414     } catch (std::exception& e) {
86415       {
86416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86417       };
86418     } catch (Dali::DaliException e) {
86419       {
86420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86421       };
86422     } catch (...) {
86423       {
86424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86425       };
86426     }
86427   }
86428
86429   jresult = (void *)result;
86430   return jresult;
86431 }
86432
86433
86434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86435   void * jresult ;
86436   Dali::Toolkit::AsyncImageLoader result;
86437
86438   {
86439     try {
86440       result = Dali::Toolkit::AsyncImageLoader::New();
86441     } catch (std::out_of_range& e) {
86442       {
86443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86444       };
86445     } catch (std::exception& e) {
86446       {
86447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86448       };
86449     } catch (Dali::DaliException e) {
86450       {
86451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86452       };
86453     } catch (...) {
86454       {
86455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86456       };
86457     }
86458   }
86459
86460   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86461   return jresult;
86462 }
86463
86464
86465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86466   void * jresult ;
86467   Dali::BaseHandle arg1 ;
86468   Dali::BaseHandle *argp1 ;
86469   Dali::Toolkit::AsyncImageLoader result;
86470
86471   argp1 = (Dali::BaseHandle *)jarg1;
86472   if (!argp1) {
86473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86474     return 0;
86475   }
86476   arg1 = *argp1;
86477   {
86478     try {
86479       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86480     } catch (std::out_of_range& e) {
86481       {
86482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86483       };
86484     } catch (std::exception& e) {
86485       {
86486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86487       };
86488     } catch (Dali::DaliException e) {
86489       {
86490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86491       };
86492     } catch (...) {
86493       {
86494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86495       };
86496     }
86497   }
86498
86499   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86500   return jresult;
86501 }
86502
86503
86504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86505   unsigned int jresult ;
86506   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86507   std::string *arg2 = 0 ;
86508   uint32_t result;
86509
86510   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86511   if (!jarg2) {
86512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86513     return 0;
86514   }
86515   std::string arg2_str(jarg2);
86516   arg2 = &arg2_str;
86517   {
86518     try {
86519       result = (arg1)->Load((std::string const &)*arg2);
86520     } catch (std::out_of_range& e) {
86521       {
86522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86523       };
86524     } catch (std::exception& e) {
86525       {
86526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86527       };
86528     } catch (Dali::DaliException e) {
86529       {
86530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86531       };
86532     } catch (...) {
86533       {
86534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86535       };
86536     }
86537   }
86538
86539   jresult = result;
86540
86541   //argout typemap for const std::string&
86542
86543   return jresult;
86544 }
86545
86546
86547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86548   unsigned int jresult ;
86549   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86550   std::string *arg2 = 0 ;
86551   Dali::ImageDimensions arg3 ;
86552   Dali::ImageDimensions *argp3 ;
86553   uint32_t result;
86554
86555   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86556   if (!jarg2) {
86557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86558     return 0;
86559   }
86560   std::string arg2_str(jarg2);
86561   arg2 = &arg2_str;
86562   argp3 = (Dali::ImageDimensions *)jarg3;
86563   if (!argp3) {
86564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86565     return 0;
86566   }
86567   arg3 = *argp3;
86568   {
86569     try {
86570       result = (arg1)->Load((std::string const &)*arg2,arg3);
86571     } catch (std::out_of_range& e) {
86572       {
86573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86574       };
86575     } catch (std::exception& e) {
86576       {
86577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86578       };
86579     } catch (Dali::DaliException e) {
86580       {
86581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86582       };
86583     } catch (...) {
86584       {
86585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86586       };
86587     }
86588   }
86589
86590   jresult = result;
86591
86592   //argout typemap for const std::string&
86593
86594   return jresult;
86595 }
86596
86597
86598 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86599   unsigned int jresult ;
86600   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86601   std::string *arg2 = 0 ;
86602   Dali::ImageDimensions arg3 ;
86603   Dali::FittingMode::Type arg4 ;
86604   Dali::SamplingMode::Type arg5 ;
86605   bool arg6 ;
86606   Dali::ImageDimensions *argp3 ;
86607   uint32_t result;
86608
86609   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86610   if (!jarg2) {
86611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86612     return 0;
86613   }
86614   std::string arg2_str(jarg2);
86615   arg2 = &arg2_str;
86616   argp3 = (Dali::ImageDimensions *)jarg3;
86617   if (!argp3) {
86618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86619     return 0;
86620   }
86621   arg3 = *argp3;
86622   arg4 = (Dali::FittingMode::Type)jarg4;
86623   arg5 = (Dali::SamplingMode::Type)jarg5;
86624   arg6 = jarg6 ? true : false;
86625   {
86626     try {
86627       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86628     } catch (std::out_of_range& e) {
86629       {
86630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86631       };
86632     } catch (std::exception& e) {
86633       {
86634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86635       };
86636     } catch (Dali::DaliException e) {
86637       {
86638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86639       };
86640     } catch (...) {
86641       {
86642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86643       };
86644     }
86645   }
86646
86647   jresult = result;
86648
86649   //argout typemap for const std::string&
86650
86651   return jresult;
86652 }
86653
86654
86655 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86656   unsigned int jresult ;
86657   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86658   uint32_t arg2 ;
86659   bool result;
86660
86661   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86662   arg2 = (uint32_t)jarg2;
86663   {
86664     try {
86665       result = (bool)(arg1)->Cancel(arg2);
86666     } catch (std::out_of_range& e) {
86667       {
86668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86669       };
86670     } catch (std::exception& e) {
86671       {
86672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86673       };
86674     } catch (Dali::DaliException e) {
86675       {
86676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86677       };
86678     } catch (...) {
86679       {
86680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86681       };
86682     }
86683   }
86684
86685   jresult = result;
86686   return jresult;
86687 }
86688
86689
86690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86691   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86692
86693   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86694   {
86695     try {
86696       (arg1)->CancelAll();
86697     } catch (std::out_of_range& e) {
86698       {
86699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86700       };
86701     } catch (std::exception& e) {
86702       {
86703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86704       };
86705     } catch (Dali::DaliException e) {
86706       {
86707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86708       };
86709     } catch (...) {
86710       {
86711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86712       };
86713     }
86714   }
86715
86716 }
86717
86718
86719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86720   void * jresult ;
86721   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86722   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86723
86724   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86725   {
86726     try {
86727       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
86728     } catch (std::out_of_range& e) {
86729       {
86730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86731       };
86732     } catch (std::exception& e) {
86733       {
86734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86735       };
86736     } catch (Dali::DaliException e) {
86737       {
86738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86739       };
86740     } catch (...) {
86741       {
86742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86743       };
86744     }
86745   }
86746
86747   jresult = (void *)result;
86748   return jresult;
86749 }
86750
86751
86752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
86753   void * jresult ;
86754   std::string *arg1 = 0 ;
86755   Dali::PixelData result;
86756
86757   if (!jarg1) {
86758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86759     return 0;
86760   }
86761   std::string arg1_str(jarg1);
86762   arg1 = &arg1_str;
86763   {
86764     try {
86765       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
86766     } catch (std::out_of_range& e) {
86767       {
86768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86769       };
86770     } catch (std::exception& e) {
86771       {
86772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86773       };
86774     } catch (Dali::DaliException e) {
86775       {
86776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86777       };
86778     } catch (...) {
86779       {
86780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86781       };
86782     }
86783   }
86784
86785   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86786
86787   //argout typemap for const std::string&
86788
86789   return jresult;
86790 }
86791
86792
86793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
86794   void * jresult ;
86795   std::string *arg1 = 0 ;
86796   Dali::ImageDimensions arg2 ;
86797   Dali::ImageDimensions *argp2 ;
86798   Dali::PixelData result;
86799
86800   if (!jarg1) {
86801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86802     return 0;
86803   }
86804   std::string arg1_str(jarg1);
86805   arg1 = &arg1_str;
86806   argp2 = (Dali::ImageDimensions *)jarg2;
86807   if (!argp2) {
86808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86809     return 0;
86810   }
86811   arg2 = *argp2;
86812   {
86813     try {
86814       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
86815     } catch (std::out_of_range& e) {
86816       {
86817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86818       };
86819     } catch (std::exception& e) {
86820       {
86821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86822       };
86823     } catch (Dali::DaliException e) {
86824       {
86825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86826       };
86827     } catch (...) {
86828       {
86829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86830       };
86831     }
86832   }
86833
86834   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86835
86836   //argout typemap for const std::string&
86837
86838   return jresult;
86839 }
86840
86841
86842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
86843   void * jresult ;
86844   std::string *arg1 = 0 ;
86845   Dali::ImageDimensions arg2 ;
86846   Dali::FittingMode::Type arg3 ;
86847   Dali::SamplingMode::Type arg4 ;
86848   bool arg5 ;
86849   Dali::ImageDimensions *argp2 ;
86850   Dali::PixelData result;
86851
86852   if (!jarg1) {
86853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86854     return 0;
86855   }
86856   std::string arg1_str(jarg1);
86857   arg1 = &arg1_str;
86858   argp2 = (Dali::ImageDimensions *)jarg2;
86859   if (!argp2) {
86860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86861     return 0;
86862   }
86863   arg2 = *argp2;
86864   arg3 = (Dali::FittingMode::Type)jarg3;
86865   arg4 = (Dali::SamplingMode::Type)jarg4;
86866   arg5 = jarg5 ? true : false;
86867   {
86868     try {
86869       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
86870     } catch (std::out_of_range& e) {
86871       {
86872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86873       };
86874     } catch (std::exception& e) {
86875       {
86876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86877       };
86878     } catch (Dali::DaliException e) {
86879       {
86880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86881       };
86882     } catch (...) {
86883       {
86884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86885       };
86886     }
86887   }
86888
86889   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86890
86891   //argout typemap for const std::string&
86892
86893   return jresult;
86894 }
86895
86896
86897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
86898   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86899
86900   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86901   {
86902     try {
86903       delete arg1;
86904     } catch (std::out_of_range& e) {
86905       {
86906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86907       };
86908     } catch (std::exception& e) {
86909       {
86910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86911       };
86912     } catch (Dali::DaliException e) {
86913       {
86914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86915       };
86916     } catch (...) {
86917       {
86918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86919       };
86920     }
86921   }
86922
86923 }
86924
86925
86926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
86927   void * jresult ;
86928   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86929   Dali::Actor arg2 ;
86930   Dali::Actor arg3 ;
86931   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
86932   Dali::Actor *argp2 ;
86933   Dali::Actor *argp3 ;
86934   Dali::Actor result;
86935
86936   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86937   argp2 = (Dali::Actor *)jarg2;
86938   if (!argp2) {
86939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86940     return 0;
86941   }
86942   arg2 = *argp2;
86943   argp3 = (Dali::Actor *)jarg3;
86944   if (!argp3) {
86945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86946     return 0;
86947   }
86948   arg3 = *argp3;
86949   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
86950   {
86951     try {
86952       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
86953     } catch (std::out_of_range& e) {
86954       {
86955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86956       };
86957     } catch (std::exception& e) {
86958       {
86959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86960       };
86961     } catch (Dali::DaliException e) {
86962       {
86963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86964       };
86965     } catch (...) {
86966       {
86967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86968       };
86969     }
86970   }
86971
86972   jresult = new Dali::Actor((const Dali::Actor &)result);
86973   return jresult;
86974 }
86975
86976
86977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
86978   void * jresult ;
86979   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
86980
86981   {
86982     try {
86983       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
86984     } catch (std::out_of_range& e) {
86985       {
86986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86987       };
86988     } catch (std::exception& e) {
86989       {
86990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86991       };
86992     } catch (Dali::DaliException e) {
86993       {
86994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86995       };
86996     } catch (...) {
86997       {
86998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86999       };
87000     }
87001   }
87002
87003   jresult = (void *)result;
87004   return jresult;
87005 }
87006
87007
87008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
87009   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
87010   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87011   if (director) {
87012     director->swig_connect_director(callback0);
87013   }
87014 }
87015
87016
87017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
87018   void * jresult ;
87019   Dali::FrameCallbackInterface *result = 0 ;
87020
87021   {
87022     try {
87023       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
87024     } catch (std::out_of_range& e) {
87025       {
87026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87027       };
87028     } catch (std::exception& e) {
87029       {
87030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87031       };
87032     } catch (Dali::DaliException e) {
87033       {
87034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87035       };
87036     } catch (...) {
87037       {
87038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87039       };
87040     }
87041   }
87042
87043   jresult = (void *)result;
87044   return jresult;
87045 }
87046
87047 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
87048   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87049   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87050   return proxy->GetPosition(id, *vector3);
87051 }
87052
87053 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
87054   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87055   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87056   return proxy->SetPosition(id, *vector3);
87057 }
87058
87059 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
87060   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87061   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87062   return proxy->BakePosition(id, *vector3);
87063 }
87064
87065 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
87066   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87067   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87068   return proxy->GetSize(id, *vector3);
87069 }
87070
87071 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
87072   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87073   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87074   return proxy->SetSize(id, *vector3);
87075 }
87076 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
87077   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87078   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87079   return proxy->BakeSize(id, *vector3);
87080 }
87081
87082 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
87083   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87084   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
87085   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
87086   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
87087 }
87088
87089 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
87090   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87091   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87092   return proxy->GetScale(id,* vector3);
87093 }
87094
87095 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
87096   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87097   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87098   return proxy->SetScale(id, *vector3);
87099 }
87100
87101 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
87102   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87103   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87104   return proxy->BakeScale(id, *vector3);
87105 }
87106
87107 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
87108   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87109   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87110   return proxy->GetColor(id, *vector4);
87111 }
87112
87113 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
87114   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87115   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87116   return proxy->SetColor(id, *vector4);
87117 }
87118
87119 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
87120   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87121   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87122   return proxy->BakeColor(id, *vector4);
87123 }
87124
87125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
87126   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
87127   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87128
87129   Dali::Stage *arg1 = (Dali::Stage *) 0;
87130   Dali::Actor *arg3 = 0;
87131
87132   arg1 = (Dali::Stage *)jarg1;
87133   arg3 = (Dali::Actor *)jarg3;
87134
87135   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
87136   return;
87137 }
87138
87139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
87140
87141   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
87142   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87143
87144   Dali::Stage *arg1 = (Dali::Stage *) 0;
87145
87146   arg1 = (Dali::Stage *)jarg1;
87147
87148   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
87149   return;
87150 }
87151
87152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
87153   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
87154   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
87155   if (director) {
87156     director->swig_connect_director(callback0);
87157   }
87158 }
87159
87160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
87161   KeyboardFocusManager arg1 ;
87162   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
87163   KeyboardFocusManager *argp1 ;
87164
87165   argp1 = (KeyboardFocusManager *)jarg1;
87166   if (!argp1) {
87167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
87168     return ;
87169   }
87170   arg1 = *argp1;
87171   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
87172   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
87173   {
87174     try {
87175       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
87176     } catch (std::out_of_range& e) {
87177       {
87178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87179       };
87180     } catch (std::exception& e) {
87181       {
87182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87183       };
87184     } catch (Dali::DaliException e) {
87185       {
87186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87187       };
87188     } catch (...) {
87189       {
87190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87191       };
87192     }
87193   }
87194
87195 }
87196
87197
87198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
87199   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87200
87201   arg1 = (std::vector< unsigned int > *)jarg1;
87202   {
87203     try {
87204       (arg1)->clear();
87205     } catch (std::out_of_range& e) {
87206       {
87207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87208       };
87209     } catch (std::exception& e) {
87210       {
87211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87212       };
87213     } catch (Dali::DaliException e) {
87214       {
87215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87216       };
87217     } catch (...) {
87218       {
87219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87220       };
87221     }
87222   }
87223
87224 }
87225
87226
87227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
87228   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87229   unsigned int *arg2 = 0 ;
87230   unsigned int temp2 ;
87231
87232   arg1 = (std::vector< unsigned int > *)jarg1;
87233   temp2 = (unsigned int)jarg2;
87234   arg2 = &temp2;
87235   {
87236     try {
87237       (arg1)->push_back((unsigned int const &)*arg2);
87238     } catch (std::out_of_range& e) {
87239       {
87240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87241       };
87242     } catch (std::exception& e) {
87243       {
87244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87245       };
87246     } catch (Dali::DaliException e) {
87247       {
87248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87249       };
87250     } catch (...) {
87251       {
87252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87253       };
87254     }
87255   }
87256
87257 }
87258
87259
87260 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
87261   unsigned long jresult ;
87262   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87263   std::vector< unsigned int >::size_type result;
87264
87265   arg1 = (std::vector< unsigned int > *)jarg1;
87266   {
87267     try {
87268       result = ((std::vector< unsigned int > const *)arg1)->size();
87269     } catch (std::out_of_range& e) {
87270       {
87271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87272       };
87273     } catch (std::exception& e) {
87274       {
87275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87276       };
87277     } catch (Dali::DaliException e) {
87278       {
87279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87280       };
87281     } catch (...) {
87282       {
87283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87284       };
87285     }
87286   }
87287
87288   jresult = (unsigned long)result;
87289   return jresult;
87290 }
87291
87292
87293 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
87294   unsigned long jresult ;
87295   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87296   std::vector< unsigned int >::size_type result;
87297
87298   arg1 = (std::vector< unsigned int > *)jarg1;
87299   {
87300     try {
87301       result = ((std::vector< unsigned int > const *)arg1)->capacity();
87302     } catch (std::out_of_range& e) {
87303       {
87304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87305       };
87306     } catch (std::exception& e) {
87307       {
87308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87309       };
87310     } catch (Dali::DaliException e) {
87311       {
87312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87313       };
87314     } catch (...) {
87315       {
87316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87317       };
87318     }
87319   }
87320
87321   jresult = (unsigned long)result;
87322   return jresult;
87323 }
87324
87325
87326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
87327   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87328   std::vector< unsigned int >::size_type arg2 ;
87329
87330   arg1 = (std::vector< unsigned int > *)jarg1;
87331   arg2 = (std::vector< unsigned int >::size_type)jarg2;
87332   {
87333     try {
87334       (arg1)->reserve(arg2);
87335     } catch (std::out_of_range& e) {
87336       {
87337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87338       };
87339     } catch (std::exception& e) {
87340       {
87341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87342       };
87343     } catch (Dali::DaliException e) {
87344       {
87345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87346       };
87347     } catch (...) {
87348       {
87349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87350       };
87351     }
87352   }
87353
87354 }
87355
87356
87357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
87358   void * jresult ;
87359   std::vector< unsigned int > *result = 0 ;
87360
87361   {
87362     try {
87363       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
87364     } catch (std::out_of_range& e) {
87365       {
87366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87367       };
87368     } catch (std::exception& e) {
87369       {
87370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87371       };
87372     } catch (Dali::DaliException e) {
87373       {
87374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87375       };
87376     } catch (...) {
87377       {
87378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87379       };
87380     }
87381   }
87382
87383   jresult = (void *)result;
87384   return jresult;
87385 }
87386
87387
87388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
87389   void * jresult ;
87390   std::vector< unsigned int > *arg1 = 0 ;
87391   std::vector< unsigned int > *result = 0 ;
87392
87393   arg1 = (std::vector< unsigned int > *)jarg1;
87394   if (!arg1) {
87395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87396     return 0;
87397   }
87398   {
87399     try {
87400       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
87401     } catch (std::out_of_range& e) {
87402       {
87403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87404       };
87405     } catch (std::exception& e) {
87406       {
87407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87408       };
87409     } catch (Dali::DaliException e) {
87410       {
87411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87412       };
87413     } catch (...) {
87414       {
87415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87416       };
87417     }
87418   }
87419
87420   jresult = (void *)result;
87421   return jresult;
87422 }
87423
87424
87425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
87426   void * jresult ;
87427   int arg1 ;
87428   std::vector< unsigned int > *result = 0 ;
87429
87430   arg1 = (int)jarg1;
87431   {
87432     try {
87433       try {
87434         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
87435       }
87436       catch(std::out_of_range &_e) {
87437         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87438         return 0;
87439       }
87440
87441     } catch (std::out_of_range& e) {
87442       {
87443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87444       };
87445     } catch (std::exception& e) {
87446       {
87447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87448       };
87449     } catch (Dali::DaliException e) {
87450       {
87451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87452       };
87453     } catch (...) {
87454       {
87455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87456       };
87457     }
87458   }
87459
87460   jresult = (void *)result;
87461   return jresult;
87462 }
87463
87464
87465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
87466   unsigned int jresult ;
87467   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87468   int arg2 ;
87469   unsigned int result;
87470
87471   arg1 = (std::vector< unsigned int > *)jarg1;
87472   arg2 = (int)jarg2;
87473   {
87474     try {
87475       try {
87476         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
87477       }
87478       catch(std::out_of_range &_e) {
87479         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87480         return 0;
87481       }
87482
87483     } catch (std::out_of_range& e) {
87484       {
87485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87486       };
87487     } catch (std::exception& e) {
87488       {
87489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87490       };
87491     } catch (Dali::DaliException e) {
87492       {
87493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87494       };
87495     } catch (...) {
87496       {
87497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87498       };
87499     }
87500   }
87501
87502   jresult = result;
87503   return jresult;
87504 }
87505
87506
87507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
87508   unsigned int jresult ;
87509   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87510   int arg2 ;
87511   unsigned int *result = 0 ;
87512
87513   arg1 = (std::vector< unsigned int > *)jarg1;
87514   arg2 = (int)jarg2;
87515   {
87516     try {
87517       try {
87518         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
87519       }
87520       catch(std::out_of_range &_e) {
87521         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87522         return 0;
87523       }
87524
87525     } catch (std::out_of_range& e) {
87526       {
87527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87528       };
87529     } catch (std::exception& e) {
87530       {
87531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87532       };
87533     } catch (Dali::DaliException e) {
87534       {
87535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87536       };
87537     } catch (...) {
87538       {
87539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87540       };
87541     }
87542   }
87543
87544   jresult = *result;
87545   return jresult;
87546 }
87547
87548
87549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
87550   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87551   int arg2 ;
87552   unsigned int *arg3 = 0 ;
87553   unsigned int temp3 ;
87554
87555   arg1 = (std::vector< unsigned int > *)jarg1;
87556   arg2 = (int)jarg2;
87557   temp3 = (unsigned int)jarg3;
87558   arg3 = &temp3;
87559   {
87560     try {
87561       try {
87562         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87563       }
87564       catch(std::out_of_range &_e) {
87565         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87566         return ;
87567       }
87568
87569     } catch (std::out_of_range& e) {
87570       {
87571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87572       };
87573     } catch (std::exception& e) {
87574       {
87575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87576       };
87577     } catch (Dali::DaliException e) {
87578       {
87579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87580       };
87581     } catch (...) {
87582       {
87583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87584       };
87585     }
87586   }
87587
87588 }
87589
87590
87591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87592   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87593   std::vector< unsigned int > *arg2 = 0 ;
87594
87595   arg1 = (std::vector< unsigned int > *)jarg1;
87596   arg2 = (std::vector< unsigned int > *)jarg2;
87597   if (!arg2) {
87598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87599     return ;
87600   }
87601   {
87602     try {
87603       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87604     } catch (std::out_of_range& e) {
87605       {
87606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87607       };
87608     } catch (std::exception& e) {
87609       {
87610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87611       };
87612     } catch (Dali::DaliException e) {
87613       {
87614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87615       };
87616     } catch (...) {
87617       {
87618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87619       };
87620     }
87621   }
87622
87623 }
87624
87625
87626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87627   void * jresult ;
87628   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87629   int arg2 ;
87630   int arg3 ;
87631   std::vector< unsigned int > *result = 0 ;
87632
87633   arg1 = (std::vector< unsigned int > *)jarg1;
87634   arg2 = (int)jarg2;
87635   arg3 = (int)jarg3;
87636   {
87637     try {
87638       try {
87639         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87640       }
87641       catch(std::out_of_range &_e) {
87642         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87643         return 0;
87644       }
87645       catch(std::invalid_argument &_e) {
87646         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87647         return 0;
87648       }
87649
87650     } catch (std::out_of_range& e) {
87651       {
87652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87653       };
87654     } catch (std::exception& e) {
87655       {
87656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87657       };
87658     } catch (Dali::DaliException e) {
87659       {
87660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87661       };
87662     } catch (...) {
87663       {
87664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87665       };
87666     }
87667   }
87668
87669   jresult = (void *)result;
87670   return jresult;
87671 }
87672
87673
87674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87675   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87676   int arg2 ;
87677   unsigned int *arg3 = 0 ;
87678   unsigned int temp3 ;
87679
87680   arg1 = (std::vector< unsigned int > *)jarg1;
87681   arg2 = (int)jarg2;
87682   temp3 = (unsigned int)jarg3;
87683   arg3 = &temp3;
87684   {
87685     try {
87686       try {
87687         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87688       }
87689       catch(std::out_of_range &_e) {
87690         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87691         return ;
87692       }
87693
87694     } catch (std::out_of_range& e) {
87695       {
87696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87697       };
87698     } catch (std::exception& e) {
87699       {
87700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87701       };
87702     } catch (Dali::DaliException e) {
87703       {
87704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87705       };
87706     } catch (...) {
87707       {
87708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87709       };
87710     }
87711   }
87712
87713 }
87714
87715
87716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87717   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87718   int arg2 ;
87719   std::vector< unsigned int > *arg3 = 0 ;
87720
87721   arg1 = (std::vector< unsigned int > *)jarg1;
87722   arg2 = (int)jarg2;
87723   arg3 = (std::vector< unsigned int > *)jarg3;
87724   if (!arg3) {
87725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87726     return ;
87727   }
87728   {
87729     try {
87730       try {
87731         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87732       }
87733       catch(std::out_of_range &_e) {
87734         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87735         return ;
87736       }
87737
87738     } catch (std::out_of_range& e) {
87739       {
87740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87741       };
87742     } catch (std::exception& e) {
87743       {
87744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87745       };
87746     } catch (Dali::DaliException e) {
87747       {
87748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87749       };
87750     } catch (...) {
87751       {
87752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87753       };
87754     }
87755   }
87756
87757 }
87758
87759
87760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
87761   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87762   int arg2 ;
87763
87764   arg1 = (std::vector< unsigned int > *)jarg1;
87765   arg2 = (int)jarg2;
87766   {
87767     try {
87768       try {
87769         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
87770       }
87771       catch(std::out_of_range &_e) {
87772         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87773         return ;
87774       }
87775
87776     } catch (std::out_of_range& e) {
87777       {
87778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87779       };
87780     } catch (std::exception& e) {
87781       {
87782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87783       };
87784     } catch (Dali::DaliException e) {
87785       {
87786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87787       };
87788     } catch (...) {
87789       {
87790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87791       };
87792     }
87793   }
87794
87795 }
87796
87797
87798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87799   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87800   int arg2 ;
87801   int arg3 ;
87802
87803   arg1 = (std::vector< unsigned int > *)jarg1;
87804   arg2 = (int)jarg2;
87805   arg3 = (int)jarg3;
87806   {
87807     try {
87808       try {
87809         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
87810       }
87811       catch(std::out_of_range &_e) {
87812         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87813         return ;
87814       }
87815       catch(std::invalid_argument &_e) {
87816         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87817         return ;
87818       }
87819
87820     } catch (std::out_of_range& e) {
87821       {
87822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87823       };
87824     } catch (std::exception& e) {
87825       {
87826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87827       };
87828     } catch (Dali::DaliException e) {
87829       {
87830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87831       };
87832     } catch (...) {
87833       {
87834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87835       };
87836     }
87837   }
87838
87839 }
87840
87841
87842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
87843   void * jresult ;
87844   unsigned int *arg1 = 0 ;
87845   int arg2 ;
87846   unsigned int temp1 ;
87847   std::vector< unsigned int > *result = 0 ;
87848
87849   temp1 = (unsigned int)jarg1;
87850   arg1 = &temp1;
87851   arg2 = (int)jarg2;
87852   {
87853     try {
87854       try {
87855         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
87856       }
87857       catch(std::out_of_range &_e) {
87858         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87859         return 0;
87860       }
87861
87862     } catch (std::out_of_range& e) {
87863       {
87864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87865       };
87866     } catch (std::exception& e) {
87867       {
87868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87869       };
87870     } catch (Dali::DaliException e) {
87871       {
87872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87873       };
87874     } catch (...) {
87875       {
87876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87877       };
87878     }
87879   }
87880
87881   jresult = (void *)result;
87882   return jresult;
87883 }
87884
87885
87886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
87887   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87888
87889   arg1 = (std::vector< unsigned int > *)jarg1;
87890   {
87891     try {
87892       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
87893     } catch (std::out_of_range& e) {
87894       {
87895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87896       };
87897     } catch (std::exception& e) {
87898       {
87899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87900       };
87901     } catch (Dali::DaliException e) {
87902       {
87903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87904       };
87905     } catch (...) {
87906       {
87907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87908       };
87909     }
87910   }
87911
87912 }
87913
87914
87915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87916   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87917   int arg2 ;
87918   int arg3 ;
87919
87920   arg1 = (std::vector< unsigned int > *)jarg1;
87921   arg2 = (int)jarg2;
87922   arg3 = (int)jarg3;
87923   {
87924     try {
87925       try {
87926         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87927       }
87928       catch(std::out_of_range &_e) {
87929         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87930         return ;
87931       }
87932       catch(std::invalid_argument &_e) {
87933         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87934         return ;
87935       }
87936
87937     } catch (std::out_of_range& e) {
87938       {
87939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87940       };
87941     } catch (std::exception& e) {
87942       {
87943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87944       };
87945     } catch (Dali::DaliException e) {
87946       {
87947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87948       };
87949     } catch (...) {
87950       {
87951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87952       };
87953     }
87954   }
87955
87956 }
87957
87958
87959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87960   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87961   int arg2 ;
87962   std::vector< unsigned int > *arg3 = 0 ;
87963
87964   arg1 = (std::vector< unsigned int > *)jarg1;
87965   arg2 = (int)jarg2;
87966   arg3 = (std::vector< unsigned int > *)jarg3;
87967   if (!arg3) {
87968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87969     return ;
87970   }
87971   {
87972     try {
87973       try {
87974         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87975       }
87976       catch(std::out_of_range &_e) {
87977         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87978         return ;
87979       }
87980
87981     } catch (std::out_of_range& e) {
87982       {
87983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87984       };
87985     } catch (std::exception& e) {
87986       {
87987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87988       };
87989     } catch (Dali::DaliException e) {
87990       {
87991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87992       };
87993     } catch (...) {
87994       {
87995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87996       };
87997     }
87998   }
87999
88000 }
88001
88002
88003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
88004   unsigned int jresult ;
88005   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88006   unsigned int *arg2 = 0 ;
88007   unsigned int temp2 ;
88008   bool result;
88009
88010   arg1 = (std::vector< unsigned int > *)jarg1;
88011   temp2 = (unsigned int)jarg2;
88012   arg2 = &temp2;
88013   {
88014     try {
88015       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
88016     } catch (std::out_of_range& e) {
88017       {
88018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88019       };
88020     } catch (std::exception& e) {
88021       {
88022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88023       };
88024     } catch (Dali::DaliException e) {
88025       {
88026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88027       };
88028     } catch (...) {
88029       {
88030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88031       };
88032     }
88033   }
88034
88035   jresult = result;
88036   return jresult;
88037 }
88038
88039
88040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
88041   int jresult ;
88042   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88043   unsigned int *arg2 = 0 ;
88044   unsigned int temp2 ;
88045   int result;
88046
88047   arg1 = (std::vector< unsigned int > *)jarg1;
88048   temp2 = (unsigned int)jarg2;
88049   arg2 = &temp2;
88050   {
88051     try {
88052       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
88053     } catch (std::out_of_range& e) {
88054       {
88055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88056       };
88057     } catch (std::exception& e) {
88058       {
88059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88060       };
88061     } catch (Dali::DaliException e) {
88062       {
88063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88064       };
88065     } catch (...) {
88066       {
88067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88068       };
88069     }
88070   }
88071
88072   jresult = result;
88073   return jresult;
88074 }
88075
88076
88077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
88078   int jresult ;
88079   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88080   unsigned int *arg2 = 0 ;
88081   unsigned int temp2 ;
88082   int result;
88083
88084   arg1 = (std::vector< unsigned int > *)jarg1;
88085   temp2 = (unsigned int)jarg2;
88086   arg2 = &temp2;
88087   {
88088     try {
88089       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
88090     } catch (std::out_of_range& e) {
88091       {
88092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88093       };
88094     } catch (std::exception& e) {
88095       {
88096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88097       };
88098     } catch (Dali::DaliException e) {
88099       {
88100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88101       };
88102     } catch (...) {
88103       {
88104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88105       };
88106     }
88107   }
88108
88109   jresult = result;
88110   return jresult;
88111 }
88112
88113
88114 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
88115   unsigned int jresult ;
88116   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88117   unsigned int *arg2 = 0 ;
88118   unsigned int temp2 ;
88119   bool result;
88120
88121   arg1 = (std::vector< unsigned int > *)jarg1;
88122   temp2 = (unsigned int)jarg2;
88123   arg2 = &temp2;
88124   {
88125     try {
88126       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
88127     } catch (std::out_of_range& e) {
88128       {
88129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88130       };
88131     } catch (std::exception& e) {
88132       {
88133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88134       };
88135     } catch (Dali::DaliException e) {
88136       {
88137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88138       };
88139     } catch (...) {
88140       {
88141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88142       };
88143     }
88144   }
88145
88146   jresult = result;
88147   return jresult;
88148 }
88149
88150
88151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
88152   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88153
88154   arg1 = (std::vector< unsigned int > *)jarg1;
88155   {
88156     try {
88157       delete arg1;
88158     } catch (std::out_of_range& e) {
88159       {
88160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88161       };
88162     } catch (std::exception& e) {
88163       {
88164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88165       };
88166     } catch (Dali::DaliException e) {
88167       {
88168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88169       };
88170     } catch (...) {
88171       {
88172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88173       };
88174     }
88175   }
88176
88177 }
88178
88179
88180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
88181   void * jresult ;
88182   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88183
88184   {
88185     try {
88186       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
88187     } catch (std::out_of_range& e) {
88188       {
88189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88190       };
88191     } catch (std::exception& e) {
88192       {
88193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88194       };
88195     } catch (Dali::DaliException e) {
88196       {
88197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88198       };
88199     } catch (...) {
88200       {
88201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88202       };
88203     }
88204   }
88205
88206   jresult = (void *)result;
88207   return jresult;
88208 }
88209
88210
88211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
88212   void * jresult ;
88213   unsigned int arg1 ;
88214   Dali::Actor arg2 ;
88215   Dali::Actor *argp2 ;
88216   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88217
88218   arg1 = (unsigned int)jarg1;
88219   argp2 = (Dali::Actor *)jarg2;
88220   if (!argp2) {
88221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88222     return 0;
88223   }
88224   arg2 = *argp2;
88225   {
88226     try {
88227       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
88228     } catch (std::out_of_range& e) {
88229       {
88230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88231       };
88232     } catch (std::exception& e) {
88233       {
88234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88235       };
88236     } catch (Dali::DaliException e) {
88237       {
88238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88239       };
88240     } catch (...) {
88241       {
88242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88243       };
88244     }
88245   }
88246
88247   jresult = (void *)result;
88248   return jresult;
88249 }
88250
88251
88252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
88253   void * jresult ;
88254   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88255   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88256
88257   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88258   if (!arg1) {
88259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88260     return 0;
88261   }
88262   {
88263     try {
88264       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
88265     } catch (std::out_of_range& e) {
88266       {
88267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88268       };
88269     } catch (std::exception& e) {
88270       {
88271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88272       };
88273     } catch (Dali::DaliException e) {
88274       {
88275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88276       };
88277     } catch (...) {
88278       {
88279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88280       };
88281     }
88282   }
88283
88284   jresult = (void *)result;
88285   return jresult;
88286 }
88287
88288
88289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
88290   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88291   unsigned int arg2 ;
88292
88293   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88294   arg2 = (unsigned int)jarg2;
88295   if (arg1) (arg1)->first = arg2;
88296 }
88297
88298
88299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
88300   unsigned int jresult ;
88301   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88302   unsigned int result;
88303
88304   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88305   result = (unsigned int) ((arg1)->first);
88306   jresult = result;
88307   return jresult;
88308 }
88309
88310
88311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
88312   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88313   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
88314
88315   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88316   arg2 = (Dali::Actor *)jarg2;
88317   if (arg1) (arg1)->second = *arg2;
88318 }
88319
88320
88321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
88322   void * jresult ;
88323   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88324   Dali::Actor *result = 0 ;
88325
88326   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88327   result = (Dali::Actor *)& ((arg1)->second);
88328   jresult = (void *)result;
88329   return jresult;
88330 }
88331
88332
88333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
88334   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88335
88336   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88337   {
88338     try {
88339       delete arg1;
88340     } catch (std::out_of_range& e) {
88341       {
88342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88343       };
88344     } catch (std::exception& e) {
88345       {
88346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88347       };
88348     } catch (Dali::DaliException e) {
88349       {
88350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88351       };
88352     } catch (...) {
88353       {
88354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88355       };
88356     }
88357   }
88358
88359 }
88360
88361
88362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
88363   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88364
88365   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88366   {
88367     try {
88368       (arg1)->clear();
88369     } catch (std::out_of_range& e) {
88370       {
88371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88372       };
88373     } catch (std::exception& e) {
88374       {
88375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88376       };
88377     } catch (Dali::DaliException e) {
88378       {
88379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88380       };
88381     } catch (...) {
88382       {
88383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88384       };
88385     }
88386   }
88387
88388 }
88389
88390
88391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
88392   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88393   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
88394
88395   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88396   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
88397   if (!arg2) {
88398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88399     return ;
88400   }
88401   {
88402     try {
88403       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
88404     } catch (std::out_of_range& e) {
88405       {
88406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88407       };
88408     } catch (std::exception& e) {
88409       {
88410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88411       };
88412     } catch (Dali::DaliException e) {
88413       {
88414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88415       };
88416     } catch (...) {
88417       {
88418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88419       };
88420     }
88421   }
88422
88423 }
88424
88425
88426 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
88427   unsigned long jresult ;
88428   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88429   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88430
88431   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88432   {
88433     try {
88434       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
88435     } catch (std::out_of_range& e) {
88436       {
88437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88438       };
88439     } catch (std::exception& e) {
88440       {
88441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88442       };
88443     } catch (Dali::DaliException e) {
88444       {
88445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88446       };
88447     } catch (...) {
88448       {
88449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88450       };
88451     }
88452   }
88453
88454   jresult = (unsigned long)result;
88455   return jresult;
88456 }
88457
88458
88459 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
88460   unsigned long jresult ;
88461   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88462   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88463
88464   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88465   {
88466     try {
88467       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
88468     } catch (std::out_of_range& e) {
88469       {
88470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88471       };
88472     } catch (std::exception& e) {
88473       {
88474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88475       };
88476     } catch (Dali::DaliException e) {
88477       {
88478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88479       };
88480     } catch (...) {
88481       {
88482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88483       };
88484     }
88485   }
88486
88487   jresult = (unsigned long)result;
88488   return jresult;
88489 }
88490
88491
88492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
88493   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88494   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
88495
88496   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88497   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
88498   {
88499     try {
88500       (arg1)->reserve(arg2);
88501     } catch (std::out_of_range& e) {
88502       {
88503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88504       };
88505     } catch (std::exception& e) {
88506       {
88507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88508       };
88509     } catch (Dali::DaliException e) {
88510       {
88511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88512       };
88513     } catch (...) {
88514       {
88515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88516       };
88517     }
88518   }
88519
88520 }
88521
88522
88523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
88524   void * jresult ;
88525   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88526
88527   {
88528     try {
88529       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
88530     } catch (std::out_of_range& e) {
88531       {
88532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88533       };
88534     } catch (std::exception& e) {
88535       {
88536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88537       };
88538     } catch (Dali::DaliException e) {
88539       {
88540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88541       };
88542     } catch (...) {
88543       {
88544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88545       };
88546     }
88547   }
88548
88549   jresult = (void *)result;
88550   return jresult;
88551 }
88552
88553
88554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
88555   void * jresult ;
88556   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
88557   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88558
88559   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88560   if (!arg1) {
88561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88562     return 0;
88563   }
88564   {
88565     try {
88566       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);
88567     } catch (std::out_of_range& e) {
88568       {
88569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88570       };
88571     } catch (std::exception& e) {
88572       {
88573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88574       };
88575     } catch (Dali::DaliException e) {
88576       {
88577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88578       };
88579     } catch (...) {
88580       {
88581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88582       };
88583     }
88584   }
88585
88586   jresult = (void *)result;
88587   return jresult;
88588 }
88589
88590
88591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
88592   void * jresult ;
88593   int arg1 ;
88594   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88595
88596   arg1 = (int)jarg1;
88597   {
88598     try {
88599       try {
88600         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);
88601       }
88602       catch(std::out_of_range &_e) {
88603         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88604         return 0;
88605       }
88606
88607     } catch (std::out_of_range& e) {
88608       {
88609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88610       };
88611     } catch (std::exception& e) {
88612       {
88613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88614       };
88615     } catch (Dali::DaliException e) {
88616       {
88617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88618       };
88619     } catch (...) {
88620       {
88621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88622       };
88623     }
88624   }
88625
88626   jresult = (void *)result;
88627   return jresult;
88628 }
88629
88630
88631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
88632   void * jresult ;
88633   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88634   int arg2 ;
88635   std::pair< unsigned int,Dali::Actor > result;
88636
88637   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88638   arg2 = (int)jarg2;
88639   {
88640     try {
88641       try {
88642         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
88643       }
88644       catch(std::out_of_range &_e) {
88645         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88646         return 0;
88647       }
88648
88649     } catch (std::out_of_range& e) {
88650       {
88651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88652       };
88653     } catch (std::exception& e) {
88654       {
88655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88656       };
88657     } catch (Dali::DaliException e) {
88658       {
88659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88660       };
88661     } catch (...) {
88662       {
88663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88664       };
88665     }
88666   }
88667
88668   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
88669   return jresult;
88670 }
88671
88672
88673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
88674   void * jresult ;
88675   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88676   int arg2 ;
88677   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88678
88679   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88680   arg2 = (int)jarg2;
88681   {
88682     try {
88683       try {
88684         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
88685       }
88686       catch(std::out_of_range &_e) {
88687         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88688         return 0;
88689       }
88690
88691     } catch (std::out_of_range& e) {
88692       {
88693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88694       };
88695     } catch (std::exception& e) {
88696       {
88697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88698       };
88699     } catch (Dali::DaliException e) {
88700       {
88701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88702       };
88703     } catch (...) {
88704       {
88705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88706       };
88707     }
88708   }
88709
88710   jresult = (void *)result;
88711   return jresult;
88712 }
88713
88714
88715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88716   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88717   int arg2 ;
88718   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88719
88720   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88721   arg2 = (int)jarg2;
88722   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88723   if (!arg3) {
88724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88725     return ;
88726   }
88727   {
88728     try {
88729       try {
88730         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);
88731       }
88732       catch(std::out_of_range &_e) {
88733         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88734         return ;
88735       }
88736
88737     } catch (std::out_of_range& e) {
88738       {
88739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88740       };
88741     } catch (std::exception& e) {
88742       {
88743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88744       };
88745     } catch (Dali::DaliException e) {
88746       {
88747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88748       };
88749     } catch (...) {
88750       {
88751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88752       };
88753     }
88754   }
88755
88756 }
88757
88758
88759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
88760   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88761   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
88762
88763   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88764   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
88765   if (!arg2) {
88766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88767     return ;
88768   }
88769   {
88770     try {
88771       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);
88772     } catch (std::out_of_range& e) {
88773       {
88774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88775       };
88776     } catch (std::exception& e) {
88777       {
88778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88779       };
88780     } catch (Dali::DaliException e) {
88781       {
88782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88783       };
88784     } catch (...) {
88785       {
88786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88787       };
88788     }
88789   }
88790
88791 }
88792
88793
88794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88795   void * jresult ;
88796   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88797   int arg2 ;
88798   int arg3 ;
88799   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88800
88801   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88802   arg2 = (int)jarg2;
88803   arg3 = (int)jarg3;
88804   {
88805     try {
88806       try {
88807         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);
88808       }
88809       catch(std::out_of_range &_e) {
88810         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88811         return 0;
88812       }
88813       catch(std::invalid_argument &_e) {
88814         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88815         return 0;
88816       }
88817
88818     } catch (std::out_of_range& e) {
88819       {
88820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88821       };
88822     } catch (std::exception& e) {
88823       {
88824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88825       };
88826     } catch (Dali::DaliException e) {
88827       {
88828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88829       };
88830     } catch (...) {
88831       {
88832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88833       };
88834     }
88835   }
88836
88837   jresult = (void *)result;
88838   return jresult;
88839 }
88840
88841
88842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88843   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88844   int arg2 ;
88845   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88846
88847   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88848   arg2 = (int)jarg2;
88849   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88850   if (!arg3) {
88851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88852     return ;
88853   }
88854   {
88855     try {
88856       try {
88857         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);
88858       }
88859       catch(std::out_of_range &_e) {
88860         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88861         return ;
88862       }
88863
88864     } catch (std::out_of_range& e) {
88865       {
88866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88867       };
88868     } catch (std::exception& e) {
88869       {
88870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88871       };
88872     } catch (Dali::DaliException e) {
88873       {
88874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88875       };
88876     } catch (...) {
88877       {
88878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88879       };
88880     }
88881   }
88882
88883 }
88884
88885
88886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88887   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88888   int arg2 ;
88889   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88890
88891   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88892   arg2 = (int)jarg2;
88893   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88894   if (!arg3) {
88895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88896     return ;
88897   }
88898   {
88899     try {
88900       try {
88901         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);
88902       }
88903       catch(std::out_of_range &_e) {
88904         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88905         return ;
88906       }
88907
88908     } catch (std::out_of_range& e) {
88909       {
88910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88911       };
88912     } catch (std::exception& e) {
88913       {
88914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88915       };
88916     } catch (Dali::DaliException e) {
88917       {
88918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88919       };
88920     } catch (...) {
88921       {
88922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88923       };
88924     }
88925   }
88926
88927 }
88928
88929
88930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
88931   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88932   int arg2 ;
88933
88934   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88935   arg2 = (int)jarg2;
88936   {
88937     try {
88938       try {
88939         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
88940       }
88941       catch(std::out_of_range &_e) {
88942         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88943         return ;
88944       }
88945
88946     } catch (std::out_of_range& e) {
88947       {
88948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88949       };
88950     } catch (std::exception& e) {
88951       {
88952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88953       };
88954     } catch (Dali::DaliException e) {
88955       {
88956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88957       };
88958     } catch (...) {
88959       {
88960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88961       };
88962     }
88963   }
88964
88965 }
88966
88967
88968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88969   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88970   int arg2 ;
88971   int arg3 ;
88972
88973   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88974   arg2 = (int)jarg2;
88975   arg3 = (int)jarg3;
88976   {
88977     try {
88978       try {
88979         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
88980       }
88981       catch(std::out_of_range &_e) {
88982         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88983         return ;
88984       }
88985       catch(std::invalid_argument &_e) {
88986         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88987         return ;
88988       }
88989
88990     } catch (std::out_of_range& e) {
88991       {
88992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88993       };
88994     } catch (std::exception& e) {
88995       {
88996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88997       };
88998     } catch (Dali::DaliException e) {
88999       {
89000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89001       };
89002     } catch (...) {
89003       {
89004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89005       };
89006     }
89007   }
89008
89009 }
89010
89011
89012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
89013   void * jresult ;
89014   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
89015   int arg2 ;
89016   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
89017
89018   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
89019   if (!arg1) {
89020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
89021     return 0;
89022   }
89023   arg2 = (int)jarg2;
89024   {
89025     try {
89026       try {
89027         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);
89028       }
89029       catch(std::out_of_range &_e) {
89030         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89031         return 0;
89032       }
89033
89034     } catch (std::out_of_range& e) {
89035       {
89036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89037       };
89038     } catch (std::exception& e) {
89039       {
89040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89041       };
89042     } catch (Dali::DaliException e) {
89043       {
89044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89045       };
89046     } catch (...) {
89047       {
89048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89049       };
89050     }
89051   }
89052
89053   jresult = (void *)result;
89054   return jresult;
89055 }
89056
89057
89058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
89059   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89060
89061   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89062   {
89063     try {
89064       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
89065     } catch (std::out_of_range& e) {
89066       {
89067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89068       };
89069     } catch (std::exception& e) {
89070       {
89071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89072       };
89073     } catch (Dali::DaliException e) {
89074       {
89075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89076       };
89077     } catch (...) {
89078       {
89079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89080       };
89081     }
89082   }
89083
89084 }
89085
89086
89087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89088   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89089   int arg2 ;
89090   int arg3 ;
89091
89092   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89093   arg2 = (int)jarg2;
89094   arg3 = (int)jarg3;
89095   {
89096     try {
89097       try {
89098         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89099       }
89100       catch(std::out_of_range &_e) {
89101         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89102         return ;
89103       }
89104       catch(std::invalid_argument &_e) {
89105         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89106         return ;
89107       }
89108
89109     } catch (std::out_of_range& e) {
89110       {
89111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89112       };
89113     } catch (std::exception& e) {
89114       {
89115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89116       };
89117     } catch (Dali::DaliException e) {
89118       {
89119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89120       };
89121     } catch (...) {
89122       {
89123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89124       };
89125     }
89126   }
89127
89128 }
89129
89130
89131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89132   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89133   int arg2 ;
89134   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
89135
89136   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89137   arg2 = (int)jarg2;
89138   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
89139   if (!arg3) {
89140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89141     return ;
89142   }
89143   {
89144     try {
89145       try {
89146         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);
89147       }
89148       catch(std::out_of_range &_e) {
89149         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89150         return ;
89151       }
89152
89153     } catch (std::out_of_range& e) {
89154       {
89155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89156       };
89157     } catch (std::exception& e) {
89158       {
89159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89160       };
89161     } catch (Dali::DaliException e) {
89162       {
89163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89164       };
89165     } catch (...) {
89166       {
89167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89168       };
89169     }
89170   }
89171
89172 }
89173
89174
89175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
89176   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89177
89178   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89179   {
89180     try {
89181       delete arg1;
89182     } catch (std::out_of_range& e) {
89183       {
89184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89185       };
89186     } catch (std::exception& e) {
89187       {
89188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89189       };
89190     } catch (Dali::DaliException e) {
89191       {
89192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89193       };
89194     } catch (...) {
89195       {
89196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89197       };
89198     }
89199   }
89200
89201 }
89202
89203
89204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
89205   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89206
89207   arg1 = (std::vector< Dali::Actor > *)jarg1;
89208   {
89209     try {
89210       (arg1)->clear();
89211     } catch (std::out_of_range& e) {
89212       {
89213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89214       };
89215     } catch (std::exception& e) {
89216       {
89217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89218       };
89219     } catch (Dali::DaliException e) {
89220       {
89221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89222       };
89223     } catch (...) {
89224       {
89225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89226       };
89227     }
89228   }
89229
89230 }
89231
89232
89233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
89234   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89235   Dali::Actor *arg2 = 0 ;
89236
89237   arg1 = (std::vector< Dali::Actor > *)jarg1;
89238   arg2 = (Dali::Actor *)jarg2;
89239   if (!arg2) {
89240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89241     return ;
89242   }
89243   {
89244     try {
89245       (arg1)->push_back((Dali::Actor const &)*arg2);
89246     } catch (std::out_of_range& e) {
89247       {
89248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89249       };
89250     } catch (std::exception& e) {
89251       {
89252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89253       };
89254     } catch (Dali::DaliException e) {
89255       {
89256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89257       };
89258     } catch (...) {
89259       {
89260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89261       };
89262     }
89263   }
89264
89265 }
89266
89267
89268 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
89269   unsigned long jresult ;
89270   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89271   std::vector< Dali::Actor >::size_type result;
89272
89273   arg1 = (std::vector< Dali::Actor > *)jarg1;
89274   {
89275     try {
89276       result = ((std::vector< Dali::Actor > const *)arg1)->size();
89277     } catch (std::out_of_range& e) {
89278       {
89279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89280       };
89281     } catch (std::exception& e) {
89282       {
89283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89284       };
89285     } catch (Dali::DaliException e) {
89286       {
89287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89288       };
89289     } catch (...) {
89290       {
89291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89292       };
89293     }
89294   }
89295
89296   jresult = (unsigned long)result;
89297   return jresult;
89298 }
89299
89300
89301 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
89302   unsigned long jresult ;
89303   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89304   std::vector< Dali::Actor >::size_type result;
89305
89306   arg1 = (std::vector< Dali::Actor > *)jarg1;
89307   {
89308     try {
89309       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
89310     } catch (std::out_of_range& e) {
89311       {
89312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89313       };
89314     } catch (std::exception& e) {
89315       {
89316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89317       };
89318     } catch (Dali::DaliException e) {
89319       {
89320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89321       };
89322     } catch (...) {
89323       {
89324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89325       };
89326     }
89327   }
89328
89329   jresult = (unsigned long)result;
89330   return jresult;
89331 }
89332
89333
89334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
89335   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89336   std::vector< Dali::Actor >::size_type arg2 ;
89337
89338   arg1 = (std::vector< Dali::Actor > *)jarg1;
89339   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
89340   {
89341     try {
89342       (arg1)->reserve(arg2);
89343     } catch (std::out_of_range& e) {
89344       {
89345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89346       };
89347     } catch (std::exception& e) {
89348       {
89349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89350       };
89351     } catch (Dali::DaliException e) {
89352       {
89353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89354       };
89355     } catch (...) {
89356       {
89357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89358       };
89359     }
89360   }
89361
89362 }
89363
89364
89365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
89366   void * jresult ;
89367   std::vector< Dali::Actor > *result = 0 ;
89368
89369   {
89370     try {
89371       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
89372     } catch (std::out_of_range& e) {
89373       {
89374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89375       };
89376     } catch (std::exception& e) {
89377       {
89378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89379       };
89380     } catch (Dali::DaliException e) {
89381       {
89382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89383       };
89384     } catch (...) {
89385       {
89386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89387       };
89388     }
89389   }
89390
89391   jresult = (void *)result;
89392   return jresult;
89393 }
89394
89395
89396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
89397   void * jresult ;
89398   std::vector< Dali::Actor > *arg1 = 0 ;
89399   std::vector< Dali::Actor > *result = 0 ;
89400
89401   arg1 = (std::vector< Dali::Actor > *)jarg1;
89402   if (!arg1) {
89403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89404     return 0;
89405   }
89406   {
89407     try {
89408       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
89409     } catch (std::out_of_range& e) {
89410       {
89411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89412       };
89413     } catch (std::exception& e) {
89414       {
89415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89416       };
89417     } catch (Dali::DaliException e) {
89418       {
89419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89420       };
89421     } catch (...) {
89422       {
89423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89424       };
89425     }
89426   }
89427
89428   jresult = (void *)result;
89429   return jresult;
89430 }
89431
89432
89433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
89434   void * jresult ;
89435   int arg1 ;
89436   std::vector< Dali::Actor > *result = 0 ;
89437
89438   arg1 = (int)jarg1;
89439   {
89440     try {
89441       try {
89442         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
89443       }
89444       catch(std::out_of_range &_e) {
89445         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89446         return 0;
89447       }
89448
89449     } catch (std::out_of_range& e) {
89450       {
89451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89452       };
89453     } catch (std::exception& e) {
89454       {
89455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89456       };
89457     } catch (Dali::DaliException e) {
89458       {
89459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89460       };
89461     } catch (...) {
89462       {
89463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89464       };
89465     }
89466   }
89467
89468   jresult = (void *)result;
89469   return jresult;
89470 }
89471
89472
89473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
89474   void * jresult ;
89475   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89476   int arg2 ;
89477   Dali::Actor result;
89478
89479   arg1 = (std::vector< Dali::Actor > *)jarg1;
89480   arg2 = (int)jarg2;
89481   {
89482     try {
89483       try {
89484         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
89485       }
89486       catch(std::out_of_range &_e) {
89487         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89488         return 0;
89489       }
89490
89491     } catch (std::out_of_range& e) {
89492       {
89493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89494       };
89495     } catch (std::exception& e) {
89496       {
89497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89498       };
89499     } catch (Dali::DaliException e) {
89500       {
89501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89502       };
89503     } catch (...) {
89504       {
89505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89506       };
89507     }
89508   }
89509
89510   jresult = new Dali::Actor((const Dali::Actor &)result);
89511   return jresult;
89512 }
89513
89514
89515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
89516   void * jresult ;
89517   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89518   int arg2 ;
89519   Dali::Actor *result = 0 ;
89520
89521   arg1 = (std::vector< Dali::Actor > *)jarg1;
89522   arg2 = (int)jarg2;
89523   {
89524     try {
89525       try {
89526         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
89527       }
89528       catch(std::out_of_range &_e) {
89529         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89530         return 0;
89531       }
89532
89533     } catch (std::out_of_range& e) {
89534       {
89535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89536       };
89537     } catch (std::exception& e) {
89538       {
89539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89540       };
89541     } catch (Dali::DaliException e) {
89542       {
89543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89544       };
89545     } catch (...) {
89546       {
89547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89548       };
89549     }
89550   }
89551
89552   jresult = (void *)result;
89553   return jresult;
89554 }
89555
89556
89557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
89558   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89559   int arg2 ;
89560   Dali::Actor *arg3 = 0 ;
89561
89562   arg1 = (std::vector< Dali::Actor > *)jarg1;
89563   arg2 = (int)jarg2;
89564   arg3 = (Dali::Actor *)jarg3;
89565   if (!arg3) {
89566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89567     return ;
89568   }
89569   {
89570     try {
89571       try {
89572         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
89573       }
89574       catch(std::out_of_range &_e) {
89575         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89576         return ;
89577       }
89578
89579     } catch (std::out_of_range& e) {
89580       {
89581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89582       };
89583     } catch (std::exception& e) {
89584       {
89585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89586       };
89587     } catch (Dali::DaliException e) {
89588       {
89589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89590       };
89591     } catch (...) {
89592       {
89593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89594       };
89595     }
89596   }
89597
89598 }
89599
89600
89601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
89602   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89603   std::vector< Dali::Actor > *arg2 = 0 ;
89604
89605   arg1 = (std::vector< Dali::Actor > *)jarg1;
89606   arg2 = (std::vector< Dali::Actor > *)jarg2;
89607   if (!arg2) {
89608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89609     return ;
89610   }
89611   {
89612     try {
89613       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
89614     } catch (std::out_of_range& e) {
89615       {
89616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89617       };
89618     } catch (std::exception& e) {
89619       {
89620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89621       };
89622     } catch (Dali::DaliException e) {
89623       {
89624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89625       };
89626     } catch (...) {
89627       {
89628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89629       };
89630     }
89631   }
89632
89633 }
89634
89635
89636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
89637   void * jresult ;
89638   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89639   int arg2 ;
89640   int arg3 ;
89641   std::vector< Dali::Actor > *result = 0 ;
89642
89643   arg1 = (std::vector< Dali::Actor > *)jarg1;
89644   arg2 = (int)jarg2;
89645   arg3 = (int)jarg3;
89646   {
89647     try {
89648       try {
89649         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
89650       }
89651       catch(std::out_of_range &_e) {
89652         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89653         return 0;
89654       }
89655       catch(std::invalid_argument &_e) {
89656         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89657         return 0;
89658       }
89659
89660     } catch (std::out_of_range& e) {
89661       {
89662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89663       };
89664     } catch (std::exception& e) {
89665       {
89666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89667       };
89668     } catch (Dali::DaliException e) {
89669       {
89670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89671       };
89672     } catch (...) {
89673       {
89674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89675       };
89676     }
89677   }
89678
89679   jresult = (void *)result;
89680   return jresult;
89681 }
89682
89683
89684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
89685   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89686   int arg2 ;
89687   Dali::Actor *arg3 = 0 ;
89688
89689   arg1 = (std::vector< Dali::Actor > *)jarg1;
89690   arg2 = (int)jarg2;
89691   arg3 = (Dali::Actor *)jarg3;
89692   if (!arg3) {
89693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89694     return ;
89695   }
89696   {
89697     try {
89698       try {
89699         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
89700       }
89701       catch(std::out_of_range &_e) {
89702         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89703         return ;
89704       }
89705
89706     } catch (std::out_of_range& e) {
89707       {
89708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89709       };
89710     } catch (std::exception& e) {
89711       {
89712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89713       };
89714     } catch (Dali::DaliException e) {
89715       {
89716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89717       };
89718     } catch (...) {
89719       {
89720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89721       };
89722     }
89723   }
89724
89725 }
89726
89727
89728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89729   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89730   int arg2 ;
89731   std::vector< Dali::Actor > *arg3 = 0 ;
89732
89733   arg1 = (std::vector< Dali::Actor > *)jarg1;
89734   arg2 = (int)jarg2;
89735   arg3 = (std::vector< Dali::Actor > *)jarg3;
89736   if (!arg3) {
89737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89738     return ;
89739   }
89740   {
89741     try {
89742       try {
89743         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89744       }
89745       catch(std::out_of_range &_e) {
89746         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89747         return ;
89748       }
89749
89750     } catch (std::out_of_range& e) {
89751       {
89752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89753       };
89754     } catch (std::exception& e) {
89755       {
89756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89757       };
89758     } catch (Dali::DaliException e) {
89759       {
89760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89761       };
89762     } catch (...) {
89763       {
89764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89765       };
89766     }
89767   }
89768
89769 }
89770
89771
89772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
89773   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89774   int arg2 ;
89775
89776   arg1 = (std::vector< Dali::Actor > *)jarg1;
89777   arg2 = (int)jarg2;
89778   {
89779     try {
89780       try {
89781         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
89782       }
89783       catch(std::out_of_range &_e) {
89784         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89785         return ;
89786       }
89787
89788     } catch (std::out_of_range& e) {
89789       {
89790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89791       };
89792     } catch (std::exception& e) {
89793       {
89794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89795       };
89796     } catch (Dali::DaliException e) {
89797       {
89798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89799       };
89800     } catch (...) {
89801       {
89802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89803       };
89804     }
89805   }
89806
89807 }
89808
89809
89810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89811   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89812   int arg2 ;
89813   int arg3 ;
89814
89815   arg1 = (std::vector< Dali::Actor > *)jarg1;
89816   arg2 = (int)jarg2;
89817   arg3 = (int)jarg3;
89818   {
89819     try {
89820       try {
89821         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
89822       }
89823       catch(std::out_of_range &_e) {
89824         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89825         return ;
89826       }
89827       catch(std::invalid_argument &_e) {
89828         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89829         return ;
89830       }
89831
89832     } catch (std::out_of_range& e) {
89833       {
89834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89835       };
89836     } catch (std::exception& e) {
89837       {
89838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89839       };
89840     } catch (Dali::DaliException e) {
89841       {
89842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89843       };
89844     } catch (...) {
89845       {
89846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89847       };
89848     }
89849   }
89850
89851 }
89852
89853
89854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
89855   void * jresult ;
89856   Dali::Actor *arg1 = 0 ;
89857   int arg2 ;
89858   std::vector< Dali::Actor > *result = 0 ;
89859
89860   arg1 = (Dali::Actor *)jarg1;
89861   if (!arg1) {
89862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89863     return 0;
89864   }
89865   arg2 = (int)jarg2;
89866   {
89867     try {
89868       try {
89869         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
89870       }
89871       catch(std::out_of_range &_e) {
89872         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89873         return 0;
89874       }
89875
89876     } catch (std::out_of_range& e) {
89877       {
89878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89879       };
89880     } catch (std::exception& e) {
89881       {
89882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89883       };
89884     } catch (Dali::DaliException e) {
89885       {
89886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89887       };
89888     } catch (...) {
89889       {
89890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89891       };
89892     }
89893   }
89894
89895   jresult = (void *)result;
89896   return jresult;
89897 }
89898
89899
89900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
89901   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89902
89903   arg1 = (std::vector< Dali::Actor > *)jarg1;
89904   {
89905     try {
89906       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
89907     } catch (std::out_of_range& e) {
89908       {
89909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89910       };
89911     } catch (std::exception& e) {
89912       {
89913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89914       };
89915     } catch (Dali::DaliException e) {
89916       {
89917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89918       };
89919     } catch (...) {
89920       {
89921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89922       };
89923     }
89924   }
89925
89926 }
89927
89928
89929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89930   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89931   int arg2 ;
89932   int arg3 ;
89933
89934   arg1 = (std::vector< Dali::Actor > *)jarg1;
89935   arg2 = (int)jarg2;
89936   arg3 = (int)jarg3;
89937   {
89938     try {
89939       try {
89940         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89941       }
89942       catch(std::out_of_range &_e) {
89943         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89944         return ;
89945       }
89946       catch(std::invalid_argument &_e) {
89947         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89948         return ;
89949       }
89950
89951     } catch (std::out_of_range& e) {
89952       {
89953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89954       };
89955     } catch (std::exception& e) {
89956       {
89957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89958       };
89959     } catch (Dali::DaliException e) {
89960       {
89961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89962       };
89963     } catch (...) {
89964       {
89965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89966       };
89967     }
89968   }
89969
89970 }
89971
89972
89973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89974   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89975   int arg2 ;
89976   std::vector< Dali::Actor > *arg3 = 0 ;
89977
89978   arg1 = (std::vector< Dali::Actor > *)jarg1;
89979   arg2 = (int)jarg2;
89980   arg3 = (std::vector< Dali::Actor > *)jarg3;
89981   if (!arg3) {
89982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89983     return ;
89984   }
89985   {
89986     try {
89987       try {
89988         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89989       }
89990       catch(std::out_of_range &_e) {
89991         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89992         return ;
89993       }
89994
89995     } catch (std::out_of_range& e) {
89996       {
89997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89998       };
89999     } catch (std::exception& e) {
90000       {
90001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90002       };
90003     } catch (Dali::DaliException e) {
90004       {
90005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90006       };
90007     } catch (...) {
90008       {
90009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90010       };
90011     }
90012   }
90013
90014 }
90015
90016
90017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
90018   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90019
90020   arg1 = (std::vector< Dali::Actor > *)jarg1;
90021   {
90022     try {
90023       delete arg1;
90024     } catch (std::out_of_range& e) {
90025       {
90026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90027       };
90028     } catch (std::exception& e) {
90029       {
90030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90031       };
90032     } catch (Dali::DaliException e) {
90033       {
90034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90035       };
90036     } catch (...) {
90037       {
90038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90039       };
90040     }
90041   }
90042
90043 }
90044
90045
90046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
90047   unsigned int jresult ;
90048   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90049   bool result;
90050
90051   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90052   {
90053     try {
90054       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
90055     } catch (std::out_of_range& e) {
90056       {
90057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90058       };
90059     } catch (std::exception& e) {
90060       {
90061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90062       };
90063     } catch (Dali::DaliException e) {
90064       {
90065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90066       };
90067     } catch (...) {
90068       {
90069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90070       };
90071     }
90072   }
90073
90074   jresult = result;
90075   return jresult;
90076 }
90077
90078
90079 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
90080   unsigned long jresult ;
90081   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90082   std::size_t result;
90083
90084   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90085   {
90086     try {
90087       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
90088     } catch (std::out_of_range& e) {
90089       {
90090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90091       };
90092     } catch (std::exception& e) {
90093       {
90094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90095       };
90096     } catch (Dali::DaliException e) {
90097       {
90098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90099       };
90100     } catch (...) {
90101       {
90102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90103       };
90104     }
90105   }
90106
90107   jresult = (unsigned long)result;
90108   return jresult;
90109 }
90110
90111
90112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
90113   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90114   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90115
90116   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90117   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90118   {
90119     try {
90120       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
90121     } catch (std::out_of_range& e) {
90122       {
90123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90124       };
90125     } catch (std::exception& e) {
90126       {
90127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90128       };
90129     } catch (Dali::DaliException e) {
90130       {
90131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90132       };
90133     } catch (...) {
90134       {
90135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90136       };
90137     }
90138   }
90139
90140 }
90141
90142
90143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
90144   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90145   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90146
90147   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90148   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90149   {
90150     try {
90151       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
90152     } catch (std::out_of_range& e) {
90153       {
90154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90155       };
90156     } catch (std::exception& e) {
90157       {
90158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90159       };
90160     } catch (Dali::DaliException e) {
90161       {
90162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90163       };
90164     } catch (...) {
90165       {
90166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90167       };
90168     }
90169   }
90170
90171 }
90172
90173
90174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
90175   unsigned int jresult ;
90176   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90177   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
90178   bool result;
90179
90180   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90181   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
90182   if (!arg2) {
90183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
90184     return 0;
90185   }
90186   {
90187     try {
90188       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
90189     } catch (std::out_of_range& e) {
90190       {
90191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90192       };
90193     } catch (std::exception& e) {
90194       {
90195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90196       };
90197     } catch (Dali::DaliException e) {
90198       {
90199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90200       };
90201     } catch (...) {
90202       {
90203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90204       };
90205     }
90206   }
90207
90208   jresult = result;
90209   return jresult;
90210 }
90211
90212
90213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
90214   void * jresult ;
90215   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
90216
90217   {
90218     try {
90219       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
90220     } catch (std::out_of_range& e) {
90221       {
90222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90223       };
90224     } catch (std::exception& e) {
90225       {
90226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90227       };
90228     } catch (Dali::DaliException e) {
90229       {
90230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90231       };
90232     } catch (...) {
90233       {
90234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90235       };
90236     }
90237   }
90238
90239   jresult = (void *)result;
90240   return jresult;
90241 }
90242
90243
90244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
90245   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90246
90247   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90248   {
90249     try {
90250       delete arg1;
90251     } catch (std::out_of_range& e) {
90252       {
90253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90254       };
90255     } catch (std::exception& e) {
90256       {
90257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90258       };
90259     } catch (Dali::DaliException e) {
90260       {
90261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90262       };
90263     } catch (...) {
90264       {
90265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90266       };
90267     }
90268   }
90269
90270 }
90271
90272
90273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
90274   unsigned int jresult ;
90275   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90276   bool result;
90277
90278   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90279   {
90280     try {
90281       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);
90282     } catch (std::out_of_range& e) {
90283       {
90284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90285       };
90286     } catch (std::exception& e) {
90287       {
90288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90289       };
90290     } catch (Dali::DaliException e) {
90291       {
90292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90293       };
90294     } catch (...) {
90295       {
90296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90297       };
90298     }
90299   }
90300
90301   jresult = result;
90302   return jresult;
90303 }
90304
90305
90306 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
90307   unsigned long jresult ;
90308   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90309   std::size_t result;
90310
90311   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90312   {
90313     try {
90314       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);
90315     } catch (std::out_of_range& e) {
90316       {
90317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90318       };
90319     } catch (std::exception& e) {
90320       {
90321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90322       };
90323     } catch (Dali::DaliException e) {
90324       {
90325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90326       };
90327     } catch (...) {
90328       {
90329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90330       };
90331     }
90332   }
90333
90334   jresult = (unsigned long)result;
90335   return jresult;
90336 }
90337
90338
90339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
90340   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90341   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90342
90343   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90344   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90345   {
90346     try {
90347       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
90348     } catch (std::out_of_range& e) {
90349       {
90350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90351       };
90352     } catch (std::exception& e) {
90353       {
90354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90355       };
90356     } catch (Dali::DaliException e) {
90357       {
90358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90359       };
90360     } catch (...) {
90361       {
90362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90363       };
90364     }
90365   }
90366
90367 }
90368
90369
90370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
90371   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90372   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90373
90374   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90375   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90376   {
90377     try {
90378       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
90379     } catch (std::out_of_range& e) {
90380       {
90381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90382       };
90383     } catch (std::exception& e) {
90384       {
90385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90386       };
90387     } catch (Dali::DaliException e) {
90388       {
90389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90390       };
90391     } catch (...) {
90392       {
90393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90394       };
90395     }
90396   }
90397
90398 }
90399
90400
90401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90402   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90403   Dali::Actor arg2 ;
90404   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
90405   Dali::Actor *argp2 ;
90406
90407   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90408   argp2 = (Dali::Actor *)jarg2;
90409   if (!argp2) {
90410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90411     return ;
90412   }
90413   arg2 = *argp2;
90414   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
90415   {
90416     try {
90417       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
90418     } catch (std::out_of_range& e) {
90419       {
90420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90421       };
90422     } catch (std::exception& e) {
90423       {
90424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90425       };
90426     } catch (Dali::DaliException e) {
90427       {
90428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90429       };
90430     } catch (...) {
90431       {
90432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90433       };
90434     }
90435   }
90436
90437 }
90438
90439
90440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
90441   void * jresult ;
90442   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
90443
90444   {
90445     try {
90446       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
90447     } catch (std::out_of_range& e) {
90448       {
90449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90450       };
90451     } catch (std::exception& e) {
90452       {
90453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90454       };
90455     } catch (Dali::DaliException e) {
90456       {
90457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90458       };
90459     } catch (...) {
90460       {
90461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90462       };
90463     }
90464   }
90465
90466   jresult = (void *)result;
90467   return jresult;
90468 }
90469
90470
90471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
90472   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90473
90474   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90475   {
90476     try {
90477       delete arg1;
90478     } catch (std::out_of_range& e) {
90479       {
90480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90481       };
90482     } catch (std::exception& e) {
90483       {
90484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90485       };
90486     } catch (Dali::DaliException e) {
90487       {
90488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90489       };
90490     } catch (...) {
90491       {
90492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90493       };
90494     }
90495   }
90496
90497 }
90498
90499
90500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
90501   unsigned int jresult ;
90502   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90503   bool result;
90504
90505   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90506   {
90507     try {
90508       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90509     } catch (std::out_of_range& e) {
90510       {
90511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90512       };
90513     } catch (std::exception& e) {
90514       {
90515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90516       };
90517     } catch (Dali::DaliException e) {
90518       {
90519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90520       };
90521     } catch (...) {
90522       {
90523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90524       };
90525     }
90526   }
90527
90528   jresult = result;
90529   return jresult;
90530 }
90531
90532
90533 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
90534   unsigned long jresult ;
90535   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90536   std::size_t result;
90537
90538   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90539   {
90540     try {
90541       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90542     } catch (std::out_of_range& e) {
90543       {
90544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90545       };
90546     } catch (std::exception& e) {
90547       {
90548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90549       };
90550     } catch (Dali::DaliException e) {
90551       {
90552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90553       };
90554     } catch (...) {
90555       {
90556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90557       };
90558     }
90559   }
90560
90561   jresult = (unsigned long)result;
90562   return jresult;
90563 }
90564
90565
90566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
90567   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90568   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90569
90570   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90571   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90572   {
90573     try {
90574       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
90575     } catch (std::out_of_range& e) {
90576       {
90577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90578       };
90579     } catch (std::exception& e) {
90580       {
90581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90582       };
90583     } catch (Dali::DaliException e) {
90584       {
90585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90586       };
90587     } catch (...) {
90588       {
90589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90590       };
90591     }
90592   }
90593
90594 }
90595
90596
90597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90598   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90599   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90600
90601   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90602   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90603   {
90604     try {
90605       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
90606     } catch (std::out_of_range& e) {
90607       {
90608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90609       };
90610     } catch (std::exception& e) {
90611       {
90612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90613       };
90614     } catch (Dali::DaliException e) {
90615       {
90616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90617       };
90618     } catch (...) {
90619       {
90620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90621       };
90622     }
90623   }
90624
90625 }
90626
90627
90628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90629   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90630   Dali::Actor arg2 ;
90631   Dali::Actor arg3 ;
90632   Dali::Actor *argp2 ;
90633   Dali::Actor *argp3 ;
90634
90635   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90636   argp2 = (Dali::Actor *)jarg2;
90637   if (!argp2) {
90638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90639     return ;
90640   }
90641   arg2 = *argp2;
90642   argp3 = (Dali::Actor *)jarg3;
90643   if (!argp3) {
90644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90645     return ;
90646   }
90647   arg3 = *argp3;
90648   {
90649     try {
90650       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
90651     } catch (std::out_of_range& e) {
90652       {
90653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90654       };
90655     } catch (std::exception& e) {
90656       {
90657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90658       };
90659     } catch (Dali::DaliException e) {
90660       {
90661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90662       };
90663     } catch (...) {
90664       {
90665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90666       };
90667     }
90668   }
90669
90670 }
90671
90672
90673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
90674   void * jresult ;
90675   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
90676
90677   {
90678     try {
90679       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
90680     } catch (std::out_of_range& e) {
90681       {
90682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90683       };
90684     } catch (std::exception& e) {
90685       {
90686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90687       };
90688     } catch (Dali::DaliException e) {
90689       {
90690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90691       };
90692     } catch (...) {
90693       {
90694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90695       };
90696     }
90697   }
90698
90699   jresult = (void *)result;
90700   return jresult;
90701 }
90702
90703
90704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
90705   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90706
90707   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90708   {
90709     try {
90710       delete arg1;
90711     } catch (std::out_of_range& e) {
90712       {
90713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90714       };
90715     } catch (std::exception& e) {
90716       {
90717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90718       };
90719     } catch (Dali::DaliException e) {
90720       {
90721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90722       };
90723     } catch (...) {
90724       {
90725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90726       };
90727     }
90728   }
90729
90730 }
90731
90732
90733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
90734   unsigned int jresult ;
90735   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90736   bool result;
90737
90738   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90739   {
90740     try {
90741       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90742     } catch (std::out_of_range& e) {
90743       {
90744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90745       };
90746     } catch (std::exception& e) {
90747       {
90748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90749       };
90750     } catch (Dali::DaliException e) {
90751       {
90752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90753       };
90754     } catch (...) {
90755       {
90756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90757       };
90758     }
90759   }
90760
90761   jresult = result;
90762   return jresult;
90763 }
90764
90765
90766 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
90767   unsigned long jresult ;
90768   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90769   std::size_t result;
90770
90771   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90772   {
90773     try {
90774       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90775     } catch (std::out_of_range& e) {
90776       {
90777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90778       };
90779     } catch (std::exception& e) {
90780       {
90781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90782       };
90783     } catch (Dali::DaliException e) {
90784       {
90785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90786       };
90787     } catch (...) {
90788       {
90789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90790       };
90791     }
90792   }
90793
90794   jresult = (unsigned long)result;
90795   return jresult;
90796 }
90797
90798
90799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
90800   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90801   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90802
90803   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90804   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90805   {
90806     try {
90807       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
90808     } catch (std::out_of_range& e) {
90809       {
90810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90811       };
90812     } catch (std::exception& e) {
90813       {
90814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90815       };
90816     } catch (Dali::DaliException e) {
90817       {
90818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90819       };
90820     } catch (...) {
90821       {
90822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90823       };
90824     }
90825   }
90826
90827 }
90828
90829
90830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90831   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90832   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90833
90834   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90835   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90836   {
90837     try {
90838       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90839     } catch (std::out_of_range& e) {
90840       {
90841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90842       };
90843     } catch (std::exception& e) {
90844       {
90845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90846       };
90847     } catch (Dali::DaliException e) {
90848       {
90849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90850       };
90851     } catch (...) {
90852       {
90853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90854       };
90855     }
90856   }
90857
90858 }
90859
90860
90861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
90862   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90863   Dali::Actor arg2 ;
90864   bool arg3 ;
90865   Dali::Actor *argp2 ;
90866
90867   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90868   argp2 = (Dali::Actor *)jarg2;
90869   if (!argp2) {
90870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90871     return ;
90872   }
90873   arg2 = *argp2;
90874   arg3 = jarg3 ? true : false;
90875   {
90876     try {
90877       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
90878     } catch (std::out_of_range& e) {
90879       {
90880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90881       };
90882     } catch (std::exception& e) {
90883       {
90884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90885       };
90886     } catch (Dali::DaliException e) {
90887       {
90888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90889       };
90890     } catch (...) {
90891       {
90892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90893       };
90894     }
90895   }
90896
90897 }
90898
90899
90900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
90901   void * jresult ;
90902   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
90903
90904   {
90905     try {
90906       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
90907     } catch (std::out_of_range& e) {
90908       {
90909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90910       };
90911     } catch (std::exception& e) {
90912       {
90913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90914       };
90915     } catch (Dali::DaliException e) {
90916       {
90917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90918       };
90919     } catch (...) {
90920       {
90921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90922       };
90923     }
90924   }
90925
90926   jresult = (void *)result;
90927   return jresult;
90928 }
90929
90930
90931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
90932   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90933
90934   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90935   {
90936     try {
90937       delete arg1;
90938     } catch (std::out_of_range& e) {
90939       {
90940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90941       };
90942     } catch (std::exception& e) {
90943       {
90944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90945       };
90946     } catch (Dali::DaliException e) {
90947       {
90948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90949       };
90950     } catch (...) {
90951       {
90952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90953       };
90954     }
90955   }
90956
90957 }
90958
90959
90960 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
90961   unsigned int jresult ;
90962   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90963   bool result;
90964
90965   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90966   {
90967     try {
90968       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);
90969     } catch (std::out_of_range& e) {
90970       {
90971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90972       };
90973     } catch (std::exception& e) {
90974       {
90975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90976       };
90977     } catch (Dali::DaliException e) {
90978       {
90979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90980       };
90981     } catch (...) {
90982       {
90983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90984       };
90985     }
90986   }
90987
90988   jresult = result;
90989   return jresult;
90990 }
90991
90992
90993 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
90994   unsigned long jresult ;
90995   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90996   std::size_t result;
90997
90998   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90999   {
91000     try {
91001       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);
91002     } catch (std::out_of_range& e) {
91003       {
91004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91005       };
91006     } catch (std::exception& e) {
91007       {
91008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91009       };
91010     } catch (Dali::DaliException e) {
91011       {
91012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91013       };
91014     } catch (...) {
91015       {
91016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91017       };
91018     }
91019   }
91020
91021   jresult = (unsigned long)result;
91022   return jresult;
91023 }
91024
91025
91026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
91027   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91028   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
91029
91030   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91031   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
91032   {
91033     try {
91034       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
91035     } catch (std::out_of_range& e) {
91036       {
91037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91038       };
91039     } catch (std::exception& e) {
91040       {
91041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91042       };
91043     } catch (Dali::DaliException e) {
91044       {
91045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91046       };
91047     } catch (...) {
91048       {
91049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91050       };
91051     }
91052   }
91053
91054 }
91055
91056
91057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91058   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91059   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
91060
91061   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91062   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
91063   {
91064     try {
91065       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
91066     } catch (std::out_of_range& e) {
91067       {
91068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91069       };
91070     } catch (std::exception& e) {
91071       {
91072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91073       };
91074     } catch (Dali::DaliException e) {
91075       {
91076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91077       };
91078     } catch (...) {
91079       {
91080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91081       };
91082     }
91083   }
91084
91085 }
91086
91087
91088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
91089   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91090   Dali::Toolkit::StyleManager arg2 ;
91091   Dali::StyleChange::Type arg3 ;
91092   Dali::Toolkit::StyleManager *argp2 ;
91093
91094   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91095   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
91096   if (!argp2) {
91097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
91098     return ;
91099   }
91100   arg2 = *argp2;
91101   arg3 = (Dali::StyleChange::Type)jarg3;
91102   {
91103     try {
91104       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
91105     } catch (std::out_of_range& e) {
91106       {
91107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91108       };
91109     } catch (std::exception& e) {
91110       {
91111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91112       };
91113     } catch (Dali::DaliException e) {
91114       {
91115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91116       };
91117     } catch (...) {
91118       {
91119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91120       };
91121     }
91122   }
91123
91124 }
91125
91126
91127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
91128   void * jresult ;
91129   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
91130
91131   {
91132     try {
91133       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
91134     } catch (std::out_of_range& e) {
91135       {
91136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91137       };
91138     } catch (std::exception& e) {
91139       {
91140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91141       };
91142     } catch (Dali::DaliException e) {
91143       {
91144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91145       };
91146     } catch (...) {
91147       {
91148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91149       };
91150     }
91151   }
91152
91153   jresult = (void *)result;
91154   return jresult;
91155 }
91156
91157
91158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
91159   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91160
91161   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91162   {
91163     try {
91164       delete arg1;
91165     } catch (std::out_of_range& e) {
91166       {
91167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91168       };
91169     } catch (std::exception& e) {
91170       {
91171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91172       };
91173     } catch (Dali::DaliException e) {
91174       {
91175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91176       };
91177     } catch (...) {
91178       {
91179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91180       };
91181     }
91182   }
91183
91184 }
91185
91186
91187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
91188   unsigned int jresult ;
91189   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91190   bool result;
91191
91192   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91193   {
91194     try {
91195       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91196     } catch (std::out_of_range& e) {
91197       {
91198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91199       };
91200     } catch (std::exception& e) {
91201       {
91202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91203       };
91204     } catch (Dali::DaliException e) {
91205       {
91206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91207       };
91208     } catch (...) {
91209       {
91210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91211       };
91212     }
91213   }
91214
91215   jresult = result;
91216   return jresult;
91217 }
91218
91219
91220 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
91221   unsigned long jresult ;
91222   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91223   std::size_t result;
91224
91225   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91226   {
91227     try {
91228       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91229     } catch (std::out_of_range& e) {
91230       {
91231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91232       };
91233     } catch (std::exception& e) {
91234       {
91235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91236       };
91237     } catch (Dali::DaliException e) {
91238       {
91239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91240       };
91241     } catch (...) {
91242       {
91243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91244       };
91245     }
91246   }
91247
91248   jresult = (unsigned long)result;
91249   return jresult;
91250 }
91251
91252
91253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
91254   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91255   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91256
91257   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91258   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91259   {
91260     try {
91261       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
91262     } catch (std::out_of_range& e) {
91263       {
91264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91265       };
91266     } catch (std::exception& e) {
91267       {
91268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91269       };
91270     } catch (Dali::DaliException e) {
91271       {
91272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91273       };
91274     } catch (...) {
91275       {
91276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91277       };
91278     }
91279   }
91280
91281 }
91282
91283
91284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
91285   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91286   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91287
91288   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91289   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91290   {
91291     try {
91292       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
91293     } catch (std::out_of_range& e) {
91294       {
91295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91296       };
91297     } catch (std::exception& e) {
91298       {
91299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91300       };
91301     } catch (Dali::DaliException e) {
91302       {
91303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91304       };
91305     } catch (...) {
91306       {
91307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91308       };
91309     }
91310   }
91311
91312 }
91313
91314
91315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
91316   unsigned int jresult ;
91317   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91318   Dali::Toolkit::Button arg2 ;
91319   Dali::Toolkit::Button *argp2 ;
91320   bool result;
91321
91322   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91323   argp2 = (Dali::Toolkit::Button *)jarg2;
91324   if (!argp2) {
91325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
91326     return 0;
91327   }
91328   arg2 = *argp2;
91329   {
91330     try {
91331       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
91332     } catch (std::out_of_range& e) {
91333       {
91334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91335       };
91336     } catch (std::exception& e) {
91337       {
91338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91339       };
91340     } catch (Dali::DaliException e) {
91341       {
91342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91343       };
91344     } catch (...) {
91345       {
91346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91347       };
91348     }
91349   }
91350
91351   jresult = result;
91352   return jresult;
91353 }
91354
91355
91356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
91357   void * jresult ;
91358   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
91359
91360   {
91361     try {
91362       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
91363     } catch (std::out_of_range& e) {
91364       {
91365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91366       };
91367     } catch (std::exception& e) {
91368       {
91369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91370       };
91371     } catch (Dali::DaliException e) {
91372       {
91373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91374       };
91375     } catch (...) {
91376       {
91377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91378       };
91379     }
91380   }
91381
91382   jresult = (void *)result;
91383   return jresult;
91384 }
91385
91386
91387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
91388   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91389
91390   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91391   {
91392     try {
91393       delete arg1;
91394     } catch (std::out_of_range& e) {
91395       {
91396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91397       };
91398     } catch (std::exception& e) {
91399       {
91400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91401       };
91402     } catch (Dali::DaliException e) {
91403       {
91404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91405       };
91406     } catch (...) {
91407       {
91408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91409       };
91410     }
91411   }
91412
91413 }
91414
91415
91416 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
91417   unsigned int jresult ;
91418   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91419   bool result;
91420
91421   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91422   {
91423     try {
91424       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91425     } catch (std::out_of_range& e) {
91426       {
91427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91428       };
91429     } catch (std::exception& e) {
91430       {
91431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91432       };
91433     } catch (Dali::DaliException e) {
91434       {
91435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91436       };
91437     } catch (...) {
91438       {
91439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91440       };
91441     }
91442   }
91443
91444   jresult = result;
91445   return jresult;
91446 }
91447
91448
91449 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
91450   unsigned long jresult ;
91451   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91452   std::size_t result;
91453
91454   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91455   {
91456     try {
91457       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91458     } catch (std::out_of_range& e) {
91459       {
91460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91461       };
91462     } catch (std::exception& e) {
91463       {
91464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91465       };
91466     } catch (Dali::DaliException e) {
91467       {
91468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91469       };
91470     } catch (...) {
91471       {
91472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91473       };
91474     }
91475   }
91476
91477   jresult = (unsigned long)result;
91478   return jresult;
91479 }
91480
91481
91482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
91483   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91484   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91485
91486   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91487   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91488   {
91489     try {
91490       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
91491     } catch (std::out_of_range& e) {
91492       {
91493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91494       };
91495     } catch (std::exception& e) {
91496       {
91497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91498       };
91499     } catch (Dali::DaliException e) {
91500       {
91501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91502       };
91503     } catch (...) {
91504       {
91505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91506       };
91507     }
91508   }
91509
91510 }
91511
91512
91513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
91514   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91515   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91516
91517   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91518   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91519   {
91520     try {
91521       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
91522     } catch (std::out_of_range& e) {
91523       {
91524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91525       };
91526     } catch (std::exception& e) {
91527       {
91528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91529       };
91530     } catch (Dali::DaliException e) {
91531       {
91532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91533       };
91534     } catch (...) {
91535       {
91536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91537       };
91538     }
91539   }
91540
91541 }
91542
91543
91544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
91545   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91546   Dali::Toolkit::GaussianBlurView arg2 ;
91547   Dali::Toolkit::GaussianBlurView *argp2 ;
91548
91549   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91550   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
91551   if (!argp2) {
91552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
91553     return ;
91554   }
91555   arg2 = *argp2;
91556   {
91557     try {
91558       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
91559     } catch (std::out_of_range& e) {
91560       {
91561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91562       };
91563     } catch (std::exception& e) {
91564       {
91565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91566       };
91567     } catch (Dali::DaliException e) {
91568       {
91569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91570       };
91571     } catch (...) {
91572       {
91573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91574       };
91575     }
91576   }
91577
91578 }
91579
91580
91581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
91582   void * jresult ;
91583   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
91584
91585   {
91586     try {
91587       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
91588     } catch (std::out_of_range& e) {
91589       {
91590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91591       };
91592     } catch (std::exception& e) {
91593       {
91594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91595       };
91596     } catch (Dali::DaliException e) {
91597       {
91598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91599       };
91600     } catch (...) {
91601       {
91602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91603       };
91604     }
91605   }
91606
91607   jresult = (void *)result;
91608   return jresult;
91609 }
91610
91611
91612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
91613   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91614
91615   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91616   {
91617     try {
91618       delete arg1;
91619     } catch (std::out_of_range& e) {
91620       {
91621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91622       };
91623     } catch (std::exception& e) {
91624       {
91625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91626       };
91627     } catch (Dali::DaliException e) {
91628       {
91629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91630       };
91631     } catch (...) {
91632       {
91633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91634       };
91635     }
91636   }
91637
91638 }
91639
91640
91641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
91642   unsigned int jresult ;
91643   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91644   bool result;
91645
91646   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91647   {
91648     try {
91649       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);
91650     } catch (std::out_of_range& e) {
91651       {
91652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91653       };
91654     } catch (std::exception& e) {
91655       {
91656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91657       };
91658     } catch (Dali::DaliException e) {
91659       {
91660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91661       };
91662     } catch (...) {
91663       {
91664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91665       };
91666     }
91667   }
91668
91669   jresult = result;
91670   return jresult;
91671 }
91672
91673
91674 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
91675   unsigned long jresult ;
91676   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91677   std::size_t result;
91678
91679   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91680   {
91681     try {
91682       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);
91683     } catch (std::out_of_range& e) {
91684       {
91685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91686       };
91687     } catch (std::exception& e) {
91688       {
91689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91690       };
91691     } catch (Dali::DaliException e) {
91692       {
91693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91694       };
91695     } catch (...) {
91696       {
91697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91698       };
91699     }
91700   }
91701
91702   jresult = (unsigned long)result;
91703   return jresult;
91704 }
91705
91706
91707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
91708   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91709   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91710
91711   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91712   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91713   {
91714     try {
91715       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
91716     } catch (std::out_of_range& e) {
91717       {
91718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91719       };
91720     } catch (std::exception& e) {
91721       {
91722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91723       };
91724     } catch (Dali::DaliException e) {
91725       {
91726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91727       };
91728     } catch (...) {
91729       {
91730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91731       };
91732     }
91733   }
91734
91735 }
91736
91737
91738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
91739   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91740   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91741
91742   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91743   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91744   {
91745     try {
91746       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
91747     } catch (std::out_of_range& e) {
91748       {
91749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91750       };
91751     } catch (std::exception& e) {
91752       {
91753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91754       };
91755     } catch (Dali::DaliException e) {
91756       {
91757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91758       };
91759     } catch (...) {
91760       {
91761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91762       };
91763     }
91764   }
91765
91766 }
91767
91768
91769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
91770   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91771   Dali::Toolkit::PageTurnView arg2 ;
91772   unsigned int arg3 ;
91773   bool arg4 ;
91774   Dali::Toolkit::PageTurnView *argp2 ;
91775
91776   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91777   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
91778   if (!argp2) {
91779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
91780     return ;
91781   }
91782   arg2 = *argp2;
91783   arg3 = (unsigned int)jarg3;
91784   arg4 = jarg4 ? true : false;
91785   {
91786     try {
91787       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
91788     } catch (std::out_of_range& e) {
91789       {
91790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91791       };
91792     } catch (std::exception& e) {
91793       {
91794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91795       };
91796     } catch (Dali::DaliException e) {
91797       {
91798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91799       };
91800     } catch (...) {
91801       {
91802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91803       };
91804     }
91805   }
91806
91807 }
91808
91809
91810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
91811   void * jresult ;
91812   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
91813
91814   {
91815     try {
91816       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
91817     } catch (std::out_of_range& e) {
91818       {
91819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91820       };
91821     } catch (std::exception& e) {
91822       {
91823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91824       };
91825     } catch (Dali::DaliException e) {
91826       {
91827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91828       };
91829     } catch (...) {
91830       {
91831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91832       };
91833     }
91834   }
91835
91836   jresult = (void *)result;
91837   return jresult;
91838 }
91839
91840
91841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
91842   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91843
91844   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91845   {
91846     try {
91847       delete arg1;
91848     } catch (std::out_of_range& e) {
91849       {
91850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91851       };
91852     } catch (std::exception& e) {
91853       {
91854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91855       };
91856     } catch (Dali::DaliException e) {
91857       {
91858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91859       };
91860     } catch (...) {
91861       {
91862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91863       };
91864     }
91865   }
91866
91867 }
91868
91869
91870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
91871   unsigned int jresult ;
91872   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91873   bool result;
91874
91875   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91876   {
91877     try {
91878       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
91879     } catch (std::out_of_range& e) {
91880       {
91881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91882       };
91883     } catch (std::exception& e) {
91884       {
91885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91886       };
91887     } catch (Dali::DaliException e) {
91888       {
91889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91890       };
91891     } catch (...) {
91892       {
91893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91894       };
91895     }
91896   }
91897
91898   jresult = result;
91899   return jresult;
91900 }
91901
91902
91903 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
91904   unsigned long jresult ;
91905   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91906   std::size_t result;
91907
91908   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91909   {
91910     try {
91911       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
91912     } catch (std::out_of_range& e) {
91913       {
91914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91915       };
91916     } catch (std::exception& e) {
91917       {
91918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91919       };
91920     } catch (Dali::DaliException e) {
91921       {
91922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91923       };
91924     } catch (...) {
91925       {
91926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91927       };
91928     }
91929   }
91930
91931   jresult = (unsigned long)result;
91932   return jresult;
91933 }
91934
91935
91936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
91937   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91938   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
91939
91940   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91941   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
91942   {
91943     try {
91944       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
91945     } catch (std::out_of_range& e) {
91946       {
91947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91948       };
91949     } catch (std::exception& e) {
91950       {
91951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91952       };
91953     } catch (Dali::DaliException e) {
91954       {
91955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91956       };
91957     } catch (...) {
91958       {
91959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91960       };
91961     }
91962   }
91963
91964 }
91965
91966
91967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
91968   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91969   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
91970
91971   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91972   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
91973   {
91974     try {
91975       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
91976     } catch (std::out_of_range& e) {
91977       {
91978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91979       };
91980     } catch (std::exception& e) {
91981       {
91982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91983       };
91984     } catch (Dali::DaliException e) {
91985       {
91986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91987       };
91988     } catch (...) {
91989       {
91990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91991       };
91992     }
91993   }
91994
91995 }
91996
91997
91998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
91999   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92000   Dali::Toolkit::PageTurnView arg2 ;
92001   Dali::Toolkit::PageTurnView *argp2 ;
92002
92003   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92004   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
92005   if (!argp2) {
92006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
92007     return ;
92008   }
92009   arg2 = *argp2;
92010   {
92011     try {
92012       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
92013     } catch (std::out_of_range& e) {
92014       {
92015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92016       };
92017     } catch (std::exception& e) {
92018       {
92019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92020       };
92021     } catch (Dali::DaliException e) {
92022       {
92023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92024       };
92025     } catch (...) {
92026       {
92027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92028       };
92029     }
92030   }
92031
92032 }
92033
92034
92035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
92036   void * jresult ;
92037   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
92038
92039   {
92040     try {
92041       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
92042     } catch (std::out_of_range& e) {
92043       {
92044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92045       };
92046     } catch (std::exception& e) {
92047       {
92048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92049       };
92050     } catch (Dali::DaliException e) {
92051       {
92052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92053       };
92054     } catch (...) {
92055       {
92056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92057       };
92058     }
92059   }
92060
92061   jresult = (void *)result;
92062   return jresult;
92063 }
92064
92065
92066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
92067   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92068
92069   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92070   {
92071     try {
92072       delete arg1;
92073     } catch (std::out_of_range& e) {
92074       {
92075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92076       };
92077     } catch (std::exception& e) {
92078       {
92079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92080       };
92081     } catch (Dali::DaliException e) {
92082       {
92083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92084       };
92085     } catch (...) {
92086       {
92087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92088       };
92089     }
92090   }
92091
92092 }
92093
92094
92095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
92096   unsigned int jresult ;
92097   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92098   bool result;
92099
92100   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92101   {
92102     try {
92103       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);
92104     } catch (std::out_of_range& e) {
92105       {
92106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92107       };
92108     } catch (std::exception& e) {
92109       {
92110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92111       };
92112     } catch (Dali::DaliException e) {
92113       {
92114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92115       };
92116     } catch (...) {
92117       {
92118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92119       };
92120     }
92121   }
92122
92123   jresult = result;
92124   return jresult;
92125 }
92126
92127
92128 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
92129   unsigned long jresult ;
92130   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92131   std::size_t result;
92132
92133   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92134   {
92135     try {
92136       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);
92137     } catch (std::out_of_range& e) {
92138       {
92139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92140       };
92141     } catch (std::exception& e) {
92142       {
92143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92144       };
92145     } catch (Dali::DaliException e) {
92146       {
92147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92148       };
92149     } catch (...) {
92150       {
92151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92152       };
92153     }
92154   }
92155
92156   jresult = (unsigned long)result;
92157   return jresult;
92158 }
92159
92160
92161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
92162   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92163   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92164
92165   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92166   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92167   {
92168     try {
92169       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
92170     } catch (std::out_of_range& e) {
92171       {
92172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92173       };
92174     } catch (std::exception& e) {
92175       {
92176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92177       };
92178     } catch (Dali::DaliException e) {
92179       {
92180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92181       };
92182     } catch (...) {
92183       {
92184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92185       };
92186     }
92187   }
92188
92189 }
92190
92191
92192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92193   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92194   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92195
92196   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92197   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92198   {
92199     try {
92200       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92201     } catch (std::out_of_range& e) {
92202       {
92203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92204       };
92205     } catch (std::exception& e) {
92206       {
92207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92208       };
92209     } catch (Dali::DaliException e) {
92210       {
92211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92212       };
92213     } catch (...) {
92214       {
92215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92216       };
92217     }
92218   }
92219
92220 }
92221
92222
92223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
92224   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92225   Dali::Toolkit::ProgressBar arg2 ;
92226   float arg3 ;
92227   float arg4 ;
92228   Dali::Toolkit::ProgressBar *argp2 ;
92229
92230   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92231   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
92232   if (!argp2) {
92233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
92234     return ;
92235   }
92236   arg2 = *argp2;
92237   arg3 = (float)jarg3;
92238   arg4 = (float)jarg4;
92239   {
92240     try {
92241       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
92242     } catch (std::out_of_range& e) {
92243       {
92244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92245       };
92246     } catch (std::exception& e) {
92247       {
92248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92249       };
92250     } catch (Dali::DaliException e) {
92251       {
92252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92253       };
92254     } catch (...) {
92255       {
92256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92257       };
92258     }
92259   }
92260
92261 }
92262
92263
92264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
92265   void * jresult ;
92266   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
92267
92268   {
92269     try {
92270       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
92271     } catch (std::out_of_range& e) {
92272       {
92273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92274       };
92275     } catch (std::exception& e) {
92276       {
92277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92278       };
92279     } catch (Dali::DaliException e) {
92280       {
92281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92282       };
92283     } catch (...) {
92284       {
92285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92286       };
92287     }
92288   }
92289
92290   jresult = (void *)result;
92291   return jresult;
92292 }
92293
92294
92295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
92296   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92297
92298   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92299   {
92300     try {
92301       delete arg1;
92302     } catch (std::out_of_range& e) {
92303       {
92304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92305       };
92306     } catch (std::exception& e) {
92307       {
92308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92309       };
92310     } catch (Dali::DaliException e) {
92311       {
92312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92313       };
92314     } catch (...) {
92315       {
92316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92317       };
92318     }
92319   }
92320
92321 }
92322
92323
92324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
92325   unsigned int jresult ;
92326   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92327   bool result;
92328
92329   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92330   {
92331     try {
92332       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);
92333     } catch (std::out_of_range& e) {
92334       {
92335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92336       };
92337     } catch (std::exception& e) {
92338       {
92339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92340       };
92341     } catch (Dali::DaliException e) {
92342       {
92343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92344       };
92345     } catch (...) {
92346       {
92347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92348       };
92349     }
92350   }
92351
92352   jresult = result;
92353   return jresult;
92354 }
92355
92356
92357 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
92358   unsigned long jresult ;
92359   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92360   std::size_t result;
92361
92362   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92363   {
92364     try {
92365       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);
92366     } catch (std::out_of_range& e) {
92367       {
92368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92369       };
92370     } catch (std::exception& e) {
92371       {
92372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92373       };
92374     } catch (Dali::DaliException e) {
92375       {
92376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92377       };
92378     } catch (...) {
92379       {
92380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92381       };
92382     }
92383   }
92384
92385   jresult = (unsigned long)result;
92386   return jresult;
92387 }
92388
92389
92390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
92391   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92392   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92393
92394   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92395   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92396   {
92397     try {
92398       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92399     } catch (std::out_of_range& e) {
92400       {
92401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92402       };
92403     } catch (std::exception& e) {
92404       {
92405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92406       };
92407     } catch (Dali::DaliException e) {
92408       {
92409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92410       };
92411     } catch (...) {
92412       {
92413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92414       };
92415     }
92416   }
92417
92418 }
92419
92420
92421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
92422   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92423   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92424
92425   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92426   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92427   {
92428     try {
92429       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92430     } catch (std::out_of_range& e) {
92431       {
92432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92433       };
92434     } catch (std::exception& e) {
92435       {
92436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92437       };
92438     } catch (Dali::DaliException e) {
92439       {
92440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92441       };
92442     } catch (...) {
92443       {
92444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92445       };
92446     }
92447   }
92448
92449 }
92450
92451
92452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
92453   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92454   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
92455
92456   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92457   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
92458   if (!arg2) {
92459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
92460     return ;
92461   }
92462   {
92463     try {
92464       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
92465     } catch (std::out_of_range& e) {
92466       {
92467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92468       };
92469     } catch (std::exception& e) {
92470       {
92471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92472       };
92473     } catch (Dali::DaliException e) {
92474       {
92475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92476       };
92477     } catch (...) {
92478       {
92479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92480       };
92481     }
92482   }
92483
92484 }
92485
92486
92487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
92488   void * jresult ;
92489   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
92490
92491   {
92492     try {
92493       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
92494     } catch (std::out_of_range& e) {
92495       {
92496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92497       };
92498     } catch (std::exception& e) {
92499       {
92500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92501       };
92502     } catch (Dali::DaliException e) {
92503       {
92504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92505       };
92506     } catch (...) {
92507       {
92508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92509       };
92510     }
92511   }
92512
92513   jresult = (void *)result;
92514   return jresult;
92515 }
92516
92517
92518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
92519   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92520
92521   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92522   {
92523     try {
92524       delete arg1;
92525     } catch (std::out_of_range& e) {
92526       {
92527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92528       };
92529     } catch (std::exception& e) {
92530       {
92531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92532       };
92533     } catch (Dali::DaliException e) {
92534       {
92535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92536       };
92537     } catch (...) {
92538       {
92539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92540       };
92541     }
92542   }
92543
92544 }
92545
92546
92547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
92548   unsigned int jresult ;
92549   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92550   bool result;
92551
92552   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92553   {
92554     try {
92555       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92556     } catch (std::out_of_range& e) {
92557       {
92558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92559       };
92560     } catch (std::exception& e) {
92561       {
92562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92563       };
92564     } catch (Dali::DaliException e) {
92565       {
92566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92567       };
92568     } catch (...) {
92569       {
92570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92571       };
92572     }
92573   }
92574
92575   jresult = result;
92576   return jresult;
92577 }
92578
92579
92580 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
92581   unsigned long jresult ;
92582   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92583   std::size_t result;
92584
92585   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92586   {
92587     try {
92588       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92589     } catch (std::out_of_range& e) {
92590       {
92591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92592       };
92593     } catch (std::exception& e) {
92594       {
92595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92596       };
92597     } catch (Dali::DaliException e) {
92598       {
92599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92600       };
92601     } catch (...) {
92602       {
92603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92604       };
92605     }
92606   }
92607
92608   jresult = (unsigned long)result;
92609   return jresult;
92610 }
92611
92612
92613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
92614   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92615   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92616
92617   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92618   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92619   {
92620     try {
92621       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92622     } catch (std::out_of_range& e) {
92623       {
92624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92625       };
92626     } catch (std::exception& e) {
92627       {
92628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92629       };
92630     } catch (Dali::DaliException e) {
92631       {
92632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92633       };
92634     } catch (...) {
92635       {
92636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92637       };
92638     }
92639   }
92640
92641 }
92642
92643
92644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
92645   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92646   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92647
92648   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92649   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92650   {
92651     try {
92652       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92653     } catch (std::out_of_range& e) {
92654       {
92655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92656       };
92657     } catch (std::exception& e) {
92658       {
92659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92660       };
92661     } catch (Dali::DaliException e) {
92662       {
92663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92664       };
92665     } catch (...) {
92666       {
92667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92668       };
92669     }
92670   }
92671
92672 }
92673
92674
92675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
92676   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92677   Dali::Vector2 *arg2 = 0 ;
92678
92679   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92680   arg2 = (Dali::Vector2 *)jarg2;
92681   if (!arg2) {
92682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
92683     return ;
92684   }
92685   {
92686     try {
92687       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
92688     } catch (std::out_of_range& e) {
92689       {
92690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92691       };
92692     } catch (std::exception& e) {
92693       {
92694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92695       };
92696     } catch (Dali::DaliException e) {
92697       {
92698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92699       };
92700     } catch (...) {
92701       {
92702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92703       };
92704     }
92705   }
92706
92707 }
92708
92709
92710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
92711   void * jresult ;
92712   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
92713
92714   {
92715     try {
92716       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
92717     } catch (std::out_of_range& e) {
92718       {
92719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92720       };
92721     } catch (std::exception& e) {
92722       {
92723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92724       };
92725     } catch (Dali::DaliException e) {
92726       {
92727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92728       };
92729     } catch (...) {
92730       {
92731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92732       };
92733     }
92734   }
92735
92736   jresult = (void *)result;
92737   return jresult;
92738 }
92739
92740
92741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
92742   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92743
92744   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92745   {
92746     try {
92747       delete arg1;
92748     } catch (std::out_of_range& e) {
92749       {
92750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92751       };
92752     } catch (std::exception& e) {
92753       {
92754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92755       };
92756     } catch (Dali::DaliException e) {
92757       {
92758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92759       };
92760     } catch (...) {
92761       {
92762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92763       };
92764     }
92765   }
92766
92767 }
92768
92769
92770
92771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
92772   unsigned int jresult ;
92773   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92774   bool result;
92775
92776   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92777   {
92778     try {
92779       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);
92780     } catch (std::out_of_range& e) {
92781       {
92782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92783       };
92784     } catch (std::exception& e) {
92785       {
92786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92787       };
92788     } catch (Dali::DaliException e) {
92789       {
92790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92791       };
92792     } catch (...) {
92793       {
92794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92795       };
92796     }
92797   }
92798
92799   jresult = result;
92800   return jresult;
92801 }
92802
92803
92804 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
92805   unsigned long jresult ;
92806   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92807   std::size_t result;
92808
92809   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92810   {
92811     try {
92812       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);
92813     } catch (std::out_of_range& e) {
92814       {
92815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92816       };
92817     } catch (std::exception& e) {
92818       {
92819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92820       };
92821     } catch (Dali::DaliException e) {
92822       {
92823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92824       };
92825     } catch (...) {
92826       {
92827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92828       };
92829     }
92830   }
92831
92832   jresult = (unsigned long)result;
92833   return jresult;
92834 }
92835
92836
92837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
92838   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92839   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92840
92841   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92842   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92843   {
92844     try {
92845       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92846     } catch (std::out_of_range& e) {
92847       {
92848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92849       };
92850     } catch (std::exception& e) {
92851       {
92852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92853       };
92854     } catch (Dali::DaliException e) {
92855       {
92856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92857       };
92858     } catch (...) {
92859       {
92860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92861       };
92862     }
92863   }
92864
92865 }
92866
92867
92868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
92869   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92870   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92871
92872   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92873   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92874   {
92875     try {
92876       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92877     } catch (std::out_of_range& e) {
92878       {
92879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92880       };
92881     } catch (std::exception& e) {
92882       {
92883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92884       };
92885     } catch (Dali::DaliException e) {
92886       {
92887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92888       };
92889     } catch (...) {
92890       {
92891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92892       };
92893     }
92894   }
92895
92896 }
92897
92898
92899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
92900   unsigned int jresult ;
92901   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92902   Dali::Toolkit::Control arg2 ;
92903   Dali::KeyEvent *arg3 = 0 ;
92904   Dali::Toolkit::Control *argp2 ;
92905   bool result;
92906
92907   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92908   argp2 = (Dali::Toolkit::Control *)jarg2;
92909   if (!argp2) {
92910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92911     return 0;
92912   }
92913   arg2 = *argp2;
92914   arg3 = (Dali::KeyEvent *)jarg3;
92915   if (!arg3) {
92916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
92917     return 0;
92918   }
92919   {
92920     try {
92921       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);
92922     } catch (std::out_of_range& e) {
92923       {
92924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92925       };
92926     } catch (std::exception& e) {
92927       {
92928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92929       };
92930     } catch (Dali::DaliException e) {
92931       {
92932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92933       };
92934     } catch (...) {
92935       {
92936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92937       };
92938     }
92939   }
92940
92941   jresult = result;
92942   return jresult;
92943 }
92944
92945
92946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
92947   void * jresult ;
92948   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
92949
92950   {
92951     try {
92952       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
92953     } catch (std::out_of_range& e) {
92954       {
92955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92956       };
92957     } catch (std::exception& e) {
92958       {
92959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92960       };
92961     } catch (Dali::DaliException e) {
92962       {
92963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92964       };
92965     } catch (...) {
92966       {
92967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92968       };
92969     }
92970   }
92971
92972   jresult = (void *)result;
92973   return jresult;
92974 }
92975
92976
92977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
92978   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92979
92980   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92981   {
92982     try {
92983       delete arg1;
92984     } catch (std::out_of_range& e) {
92985       {
92986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92987       };
92988     } catch (std::exception& e) {
92989       {
92990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92991       };
92992     } catch (Dali::DaliException e) {
92993       {
92994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92995       };
92996     } catch (...) {
92997       {
92998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92999       };
93000     }
93001   }
93002
93003 }
93004
93005
93006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
93007   unsigned int jresult ;
93008   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93009   bool result;
93010
93011   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93012   {
93013     try {
93014       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93015     } catch (std::out_of_range& e) {
93016       {
93017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93018       };
93019     } catch (std::exception& e) {
93020       {
93021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93022       };
93023     } catch (Dali::DaliException e) {
93024       {
93025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93026       };
93027     } catch (...) {
93028       {
93029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93030       };
93031     }
93032   }
93033
93034   jresult = result;
93035   return jresult;
93036 }
93037
93038
93039 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
93040   unsigned long jresult ;
93041   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93042   std::size_t result;
93043
93044   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93045   {
93046     try {
93047       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93048     } catch (std::out_of_range& e) {
93049       {
93050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93051       };
93052     } catch (std::exception& e) {
93053       {
93054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93055       };
93056     } catch (Dali::DaliException e) {
93057       {
93058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93059       };
93060     } catch (...) {
93061       {
93062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93063       };
93064     }
93065   }
93066
93067   jresult = (unsigned long)result;
93068   return jresult;
93069 }
93070
93071
93072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
93073   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93074   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93075
93076   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93077   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93078   {
93079     try {
93080       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
93081     } catch (std::out_of_range& e) {
93082       {
93083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93084       };
93085     } catch (std::exception& e) {
93086       {
93087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93088       };
93089     } catch (Dali::DaliException e) {
93090       {
93091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93092       };
93093     } catch (...) {
93094       {
93095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93096       };
93097     }
93098   }
93099
93100 }
93101
93102
93103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
93104   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93105   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93106
93107   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93108   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93109   {
93110     try {
93111       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
93112     } catch (std::out_of_range& e) {
93113       {
93114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93115       };
93116     } catch (std::exception& e) {
93117       {
93118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93119       };
93120     } catch (Dali::DaliException e) {
93121       {
93122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93123       };
93124     } catch (...) {
93125       {
93126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93127       };
93128     }
93129   }
93130
93131 }
93132
93133
93134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
93135   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93136   Dali::Toolkit::Control arg2 ;
93137   Dali::Toolkit::Control *argp2 ;
93138
93139   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93140   argp2 = (Dali::Toolkit::Control *)jarg2;
93141   if (!argp2) {
93142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
93143     return ;
93144   }
93145   arg2 = *argp2;
93146   {
93147     try {
93148       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
93149     } catch (std::out_of_range& e) {
93150       {
93151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93152       };
93153     } catch (std::exception& e) {
93154       {
93155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93156       };
93157     } catch (Dali::DaliException e) {
93158       {
93159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93160       };
93161     } catch (...) {
93162       {
93163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93164       };
93165     }
93166   }
93167
93168 }
93169
93170
93171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
93172   void * jresult ;
93173   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
93174
93175   {
93176     try {
93177       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
93178     } catch (std::out_of_range& e) {
93179       {
93180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93181       };
93182     } catch (std::exception& e) {
93183       {
93184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93185       };
93186     } catch (Dali::DaliException e) {
93187       {
93188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93189       };
93190     } catch (...) {
93191       {
93192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93193       };
93194     }
93195   }
93196
93197   jresult = (void *)result;
93198   return jresult;
93199 }
93200
93201
93202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
93203   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93204
93205   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93206   {
93207     try {
93208       delete arg1;
93209     } catch (std::out_of_range& e) {
93210       {
93211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93212       };
93213     } catch (std::exception& e) {
93214       {
93215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93216       };
93217     } catch (Dali::DaliException e) {
93218       {
93219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93220       };
93221     } catch (...) {
93222       {
93223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93224       };
93225     }
93226   }
93227
93228 }
93229
93230
93231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
93232   unsigned int jresult ;
93233   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93234   bool result;
93235
93236   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93237   {
93238     try {
93239       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93240     } catch (std::out_of_range& e) {
93241       {
93242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93243       };
93244     } catch (std::exception& e) {
93245       {
93246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93247       };
93248     } catch (Dali::DaliException e) {
93249       {
93250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93251       };
93252     } catch (...) {
93253       {
93254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93255       };
93256     }
93257   }
93258
93259   jresult = result;
93260   return jresult;
93261 }
93262
93263
93264 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
93265   unsigned long jresult ;
93266   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93267   std::size_t result;
93268
93269   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93270   {
93271     try {
93272       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93273     } catch (std::out_of_range& e) {
93274       {
93275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93276       };
93277     } catch (std::exception& e) {
93278       {
93279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93280       };
93281     } catch (Dali::DaliException e) {
93282       {
93283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93284       };
93285     } catch (...) {
93286       {
93287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93288       };
93289     }
93290   }
93291
93292   jresult = (unsigned long)result;
93293   return jresult;
93294 }
93295
93296
93297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
93298   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93299   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93300
93301   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93302   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93303   {
93304     try {
93305       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
93306     } catch (std::out_of_range& e) {
93307       {
93308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93309       };
93310     } catch (std::exception& e) {
93311       {
93312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93313       };
93314     } catch (Dali::DaliException e) {
93315       {
93316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93317       };
93318     } catch (...) {
93319       {
93320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93321       };
93322     }
93323   }
93324
93325 }
93326
93327
93328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
93329   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93330   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93331
93332   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93333   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93334   {
93335     try {
93336       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
93337     } catch (std::out_of_range& e) {
93338       {
93339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93340       };
93341     } catch (std::exception& e) {
93342       {
93343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93344       };
93345     } catch (Dali::DaliException e) {
93346       {
93347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93348       };
93349     } catch (...) {
93350       {
93351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93352       };
93353     }
93354   }
93355
93356 }
93357
93358
93359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
93360   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93361   Dali::Toolkit::VideoView *arg2 = 0 ;
93362
93363   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93364   arg2 = (Dali::Toolkit::VideoView *)jarg2;
93365   if (!arg2) {
93366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
93367     return ;
93368   }
93369   {
93370     try {
93371       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
93372     } catch (std::out_of_range& e) {
93373       {
93374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93375       };
93376     } catch (std::exception& e) {
93377       {
93378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93379       };
93380     } catch (Dali::DaliException e) {
93381       {
93382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93383       };
93384     } catch (...) {
93385       {
93386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93387       };
93388     }
93389   }
93390
93391 }
93392
93393
93394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
93395   void * jresult ;
93396   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
93397
93398   {
93399     try {
93400       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
93401     } catch (std::out_of_range& e) {
93402       {
93403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93404       };
93405     } catch (std::exception& e) {
93406       {
93407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93408       };
93409     } catch (Dali::DaliException e) {
93410       {
93411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93412       };
93413     } catch (...) {
93414       {
93415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93416       };
93417     }
93418   }
93419
93420   jresult = (void *)result;
93421   return jresult;
93422 }
93423
93424
93425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
93426   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93427
93428   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93429   {
93430     try {
93431       delete arg1;
93432     } catch (std::out_of_range& e) {
93433       {
93434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93435       };
93436     } catch (std::exception& e) {
93437       {
93438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93439       };
93440     } catch (Dali::DaliException e) {
93441       {
93442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93443       };
93444     } catch (...) {
93445       {
93446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93447       };
93448     }
93449   }
93450
93451 }
93452
93453
93454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
93455   unsigned int jresult ;
93456   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93457   bool result;
93458
93459   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93460   {
93461     try {
93462       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93463     } catch (std::out_of_range& e) {
93464       {
93465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93466       };
93467     } catch (std::exception& e) {
93468       {
93469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93470       };
93471     } catch (Dali::DaliException e) {
93472       {
93473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93474       };
93475     } catch (...) {
93476       {
93477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93478       };
93479     }
93480   }
93481
93482   jresult = result;
93483   return jresult;
93484 }
93485
93486
93487 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
93488   unsigned long jresult ;
93489   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93490   std::size_t result;
93491
93492   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93493   {
93494     try {
93495       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93496     } catch (std::out_of_range& e) {
93497       {
93498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93499       };
93500     } catch (std::exception& e) {
93501       {
93502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93503       };
93504     } catch (Dali::DaliException e) {
93505       {
93506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93507       };
93508     } catch (...) {
93509       {
93510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93511       };
93512     }
93513   }
93514
93515   jresult = (unsigned long)result;
93516   return jresult;
93517 }
93518
93519
93520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
93521   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93522   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93523
93524   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93525   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93526   {
93527     try {
93528       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
93529     } catch (std::out_of_range& e) {
93530       {
93531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93532       };
93533     } catch (std::exception& e) {
93534       {
93535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93536       };
93537     } catch (Dali::DaliException e) {
93538       {
93539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93540       };
93541     } catch (...) {
93542       {
93543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93544       };
93545     }
93546   }
93547
93548 }
93549
93550
93551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
93552   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93553   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93554
93555   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93556   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93557   {
93558     try {
93559       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
93560     } catch (std::out_of_range& e) {
93561       {
93562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93563       };
93564     } catch (std::exception& e) {
93565       {
93566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93567       };
93568     } catch (Dali::DaliException e) {
93569       {
93570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93571       };
93572     } catch (...) {
93573       {
93574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93575       };
93576     }
93577   }
93578
93579 }
93580
93581
93582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
93583   unsigned int jresult ;
93584   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93585   Dali::Toolkit::Slider arg2 ;
93586   float arg3 ;
93587   Dali::Toolkit::Slider *argp2 ;
93588   bool result;
93589
93590   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93591   argp2 = (Dali::Toolkit::Slider *)jarg2;
93592   if (!argp2) {
93593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93594     return 0;
93595   }
93596   arg2 = *argp2;
93597   arg3 = (float)jarg3;
93598   {
93599     try {
93600       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
93601     } catch (std::out_of_range& e) {
93602       {
93603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93604       };
93605     } catch (std::exception& e) {
93606       {
93607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93608       };
93609     } catch (Dali::DaliException e) {
93610       {
93611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93612       };
93613     } catch (...) {
93614       {
93615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93616       };
93617     }
93618   }
93619
93620   jresult = result;
93621   return jresult;
93622 }
93623
93624
93625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
93626   void * jresult ;
93627   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
93628
93629   {
93630     try {
93631       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
93632     } catch (std::out_of_range& e) {
93633       {
93634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93635       };
93636     } catch (std::exception& e) {
93637       {
93638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93639       };
93640     } catch (Dali::DaliException e) {
93641       {
93642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93643       };
93644     } catch (...) {
93645       {
93646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93647       };
93648     }
93649   }
93650
93651   jresult = (void *)result;
93652   return jresult;
93653 }
93654
93655
93656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
93657   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93658
93659   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93660   {
93661     try {
93662       delete arg1;
93663     } catch (std::out_of_range& e) {
93664       {
93665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93666       };
93667     } catch (std::exception& e) {
93668       {
93669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93670       };
93671     } catch (Dali::DaliException e) {
93672       {
93673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93674       };
93675     } catch (...) {
93676       {
93677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93678       };
93679     }
93680   }
93681
93682 }
93683
93684
93685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
93686   unsigned int jresult ;
93687   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93688   bool result;
93689
93690   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93691   {
93692     try {
93693       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93694     } catch (std::out_of_range& e) {
93695       {
93696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93697       };
93698     } catch (std::exception& e) {
93699       {
93700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93701       };
93702     } catch (Dali::DaliException e) {
93703       {
93704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93705       };
93706     } catch (...) {
93707       {
93708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93709       };
93710     }
93711   }
93712
93713   jresult = result;
93714   return jresult;
93715 }
93716
93717
93718 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
93719   unsigned long jresult ;
93720   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93721   std::size_t result;
93722
93723   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93724   {
93725     try {
93726       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93727     } catch (std::out_of_range& e) {
93728       {
93729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93730       };
93731     } catch (std::exception& e) {
93732       {
93733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93734       };
93735     } catch (Dali::DaliException e) {
93736       {
93737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93738       };
93739     } catch (...) {
93740       {
93741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93742       };
93743     }
93744   }
93745
93746   jresult = (unsigned long)result;
93747   return jresult;
93748 }
93749
93750
93751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
93752   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93753   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93754
93755   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93756   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93757   {
93758     try {
93759       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
93760     } catch (std::out_of_range& e) {
93761       {
93762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93763       };
93764     } catch (std::exception& e) {
93765       {
93766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93767       };
93768     } catch (Dali::DaliException e) {
93769       {
93770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93771       };
93772     } catch (...) {
93773       {
93774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93775       };
93776     }
93777   }
93778
93779 }
93780
93781
93782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
93783   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93784   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93785
93786   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93787   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93788   {
93789     try {
93790       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
93791     } catch (std::out_of_range& e) {
93792       {
93793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93794       };
93795     } catch (std::exception& e) {
93796       {
93797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93798       };
93799     } catch (Dali::DaliException e) {
93800       {
93801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93802       };
93803     } catch (...) {
93804       {
93805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93806       };
93807     }
93808   }
93809
93810 }
93811
93812
93813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
93814   unsigned int jresult ;
93815   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93816   Dali::Toolkit::Slider arg2 ;
93817   int arg3 ;
93818   Dali::Toolkit::Slider *argp2 ;
93819   bool result;
93820
93821   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93822   argp2 = (Dali::Toolkit::Slider *)jarg2;
93823   if (!argp2) {
93824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93825     return 0;
93826   }
93827   arg2 = *argp2;
93828   arg3 = (int)jarg3;
93829   {
93830     try {
93831       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
93832     } catch (std::out_of_range& e) {
93833       {
93834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93835       };
93836     } catch (std::exception& e) {
93837       {
93838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93839       };
93840     } catch (Dali::DaliException e) {
93841       {
93842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93843       };
93844     } catch (...) {
93845       {
93846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93847       };
93848     }
93849   }
93850
93851   jresult = result;
93852   return jresult;
93853 }
93854
93855
93856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
93857   void * jresult ;
93858   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
93859
93860   {
93861     try {
93862       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
93863     } catch (std::out_of_range& e) {
93864       {
93865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93866       };
93867     } catch (std::exception& e) {
93868       {
93869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93870       };
93871     } catch (Dali::DaliException e) {
93872       {
93873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93874       };
93875     } catch (...) {
93876       {
93877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93878       };
93879     }
93880   }
93881
93882   jresult = (void *)result;
93883   return jresult;
93884 }
93885
93886
93887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
93888   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93889
93890   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93891   {
93892     try {
93893       delete arg1;
93894     } catch (std::out_of_range& e) {
93895       {
93896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93897       };
93898     } catch (std::exception& e) {
93899       {
93900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93901       };
93902     } catch (Dali::DaliException e) {
93903       {
93904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93905       };
93906     } catch (...) {
93907       {
93908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93909       };
93910     }
93911   }
93912
93913 }
93914
93915
93916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
93917   void * jresult ;
93918   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93919
93920   {
93921     try {
93922       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
93923     } catch (std::out_of_range& e) {
93924       {
93925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93926       };
93927     } catch (std::exception& e) {
93928       {
93929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93930       };
93931     } catch (Dali::DaliException e) {
93932       {
93933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93934       };
93935     } catch (...) {
93936       {
93937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93938       };
93939     }
93940   }
93941
93942   jresult = (void *)result;
93943   return jresult;
93944 }
93945
93946
93947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
93948   void * jresult ;
93949   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
93950   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93951
93952   arg1 = (Dali::Toolkit::Ruler *)jarg1;
93953   {
93954     try {
93955       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
93956     } catch (std::out_of_range& e) {
93957       {
93958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93959       };
93960     } catch (std::exception& e) {
93961       {
93962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93963       };
93964     } catch (Dali::DaliException e) {
93965       {
93966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93967       };
93968     } catch (...) {
93969       {
93970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93971       };
93972     }
93973   }
93974
93975   jresult = (void *)result;
93976   return jresult;
93977 }
93978
93979
93980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
93981   void * jresult ;
93982   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
93983   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93984
93985   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93986   if (!arg1) {
93987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93988     return 0;
93989   }
93990   {
93991     try {
93992       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
93993     } catch (std::out_of_range& e) {
93994       {
93995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93996       };
93997     } catch (std::exception& e) {
93998       {
93999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94000       };
94001     } catch (Dali::DaliException e) {
94002       {
94003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94004       };
94005     } catch (...) {
94006       {
94007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94008       };
94009     }
94010   }
94011
94012   jresult = (void *)result;
94013   return jresult;
94014 }
94015
94016
94017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
94018   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94019
94020   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94021   {
94022     try {
94023       delete arg1;
94024     } catch (std::out_of_range& e) {
94025       {
94026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94027       };
94028     } catch (std::exception& e) {
94029       {
94030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94031       };
94032     } catch (Dali::DaliException e) {
94033       {
94034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94035       };
94036     } catch (...) {
94037       {
94038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94039       };
94040     }
94041   }
94042
94043 }
94044
94045
94046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
94047   void * jresult ;
94048   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94049   Dali::Toolkit::Ruler *result = 0 ;
94050
94051   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94052   {
94053     try {
94054       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
94055     } catch (std::out_of_range& e) {
94056       {
94057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94058       };
94059     } catch (std::exception& e) {
94060       {
94061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94062       };
94063     } catch (Dali::DaliException e) {
94064       {
94065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94066       };
94067     } catch (...) {
94068       {
94069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94070       };
94071     }
94072   }
94073
94074   jresult = (void *)result;
94075   return jresult;
94076 }
94077
94078
94079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
94080   void * jresult ;
94081   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94082   Dali::Toolkit::Ruler *result = 0 ;
94083
94084   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94085   {
94086     try {
94087       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
94088     } catch (std::out_of_range& e) {
94089       {
94090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94091       };
94092     } catch (std::exception& e) {
94093       {
94094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94095       };
94096     } catch (Dali::DaliException e) {
94097       {
94098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94099       };
94100     } catch (...) {
94101       {
94102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94103       };
94104     }
94105   }
94106
94107   jresult = (void *)result;
94108   return jresult;
94109 }
94110
94111
94112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
94113   void * jresult ;
94114   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94115   Dali::Toolkit::Ruler *result = 0 ;
94116
94117   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94118   {
94119     try {
94120       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
94121     } catch (std::out_of_range& e) {
94122       {
94123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94124       };
94125     } catch (std::exception& e) {
94126       {
94127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94128       };
94129     } catch (Dali::DaliException e) {
94130       {
94131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94132       };
94133     } catch (...) {
94134       {
94135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94136       };
94137     }
94138   }
94139
94140   jresult = (void *)result;
94141   return jresult;
94142 }
94143
94144
94145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
94146   void * jresult ;
94147   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94148   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
94149   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94150
94151   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94152   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
94153   if (!arg2) {
94154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
94155     return 0;
94156   }
94157   {
94158     try {
94159       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
94160     } catch (std::out_of_range& e) {
94161       {
94162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94163       };
94164     } catch (std::exception& e) {
94165       {
94166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94167       };
94168     } catch (Dali::DaliException e) {
94169       {
94170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94171       };
94172     } catch (...) {
94173       {
94174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94175       };
94176     }
94177   }
94178
94179   jresult = (void *)result;
94180   return jresult;
94181 }
94182
94183
94184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
94185   void * jresult ;
94186   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94187   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94188   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94189
94190   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94191   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94192   {
94193     try {
94194       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
94195     } catch (std::out_of_range& e) {
94196       {
94197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94198       };
94199     } catch (std::exception& e) {
94200       {
94201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94202       };
94203     } catch (Dali::DaliException e) {
94204       {
94205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94206       };
94207     } catch (...) {
94208       {
94209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94210       };
94211     }
94212   }
94213
94214   jresult = (void *)result;
94215   return jresult;
94216 }
94217
94218
94219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
94220   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94221
94222   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94223   {
94224     try {
94225       (arg1)->Reset();
94226     } catch (std::out_of_range& e) {
94227       {
94228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94229       };
94230     } catch (std::exception& e) {
94231       {
94232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94233       };
94234     } catch (Dali::DaliException e) {
94235       {
94236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94237       };
94238     } catch (...) {
94239       {
94240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94241       };
94242     }
94243   }
94244
94245 }
94246
94247
94248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
94249   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94250   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94251
94252   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94253   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94254   {
94255     try {
94256       (arg1)->Reset(arg2);
94257     } catch (std::out_of_range& e) {
94258       {
94259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94260       };
94261     } catch (std::exception& e) {
94262       {
94263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94264       };
94265     } catch (Dali::DaliException e) {
94266       {
94267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94268       };
94269     } catch (...) {
94270       {
94271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94272       };
94273     }
94274   }
94275
94276 }
94277
94278
94279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
94280   void * jresult ;
94281   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94282   Dali::Toolkit::Ruler *result = 0 ;
94283
94284   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94285   {
94286     try {
94287       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
94288     } catch (std::out_of_range& e) {
94289       {
94290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94291       };
94292     } catch (std::exception& e) {
94293       {
94294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94295       };
94296     } catch (Dali::DaliException e) {
94297       {
94298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94299       };
94300     } catch (...) {
94301       {
94302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94303       };
94304     }
94305   }
94306
94307   jresult = (void *)result;
94308   return jresult;
94309 }
94310
94311
94312 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
94313   float jresult ;
94314   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94315   float arg2 ;
94316   float arg3 ;
94317   float result;
94318
94319   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94320   arg2 = (float)jarg2;
94321   arg3 = (float)jarg3;
94322   {
94323     try {
94324       result = (float)(*arg1)->Snap(arg2,arg3);
94325     } catch (std::out_of_range& e) {
94326       {
94327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94328       };
94329     } catch (std::exception& e) {
94330       {
94331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94332       };
94333     } catch (Dali::DaliException e) {
94334       {
94335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94336       };
94337     } catch (...) {
94338       {
94339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94340       };
94341     }
94342   }
94343
94344   jresult = result;
94345   return jresult;
94346 }
94347
94348
94349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
94350   float jresult ;
94351   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94352   float arg2 ;
94353   float result;
94354
94355   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94356   arg2 = (float)jarg2;
94357   {
94358     try {
94359       result = (float)(*arg1)->Snap(arg2);
94360     } catch (std::out_of_range& e) {
94361       {
94362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94363       };
94364     } catch (std::exception& e) {
94365       {
94366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94367       };
94368     } catch (Dali::DaliException e) {
94369       {
94370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94371       };
94372     } catch (...) {
94373       {
94374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94375       };
94376     }
94377   }
94378
94379   jresult = result;
94380   return jresult;
94381 }
94382
94383
94384 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
94385   float jresult ;
94386   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94387   unsigned int arg2 ;
94388   unsigned int *arg3 = 0 ;
94389   bool arg4 ;
94390   float result;
94391
94392   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94393   arg2 = (unsigned int)jarg2;
94394   arg3 = (unsigned int *)jarg3;
94395   arg4 = jarg4 ? true : false;
94396   {
94397     try {
94398       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
94399     } catch (std::out_of_range& e) {
94400       {
94401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94402       };
94403     } catch (std::exception& e) {
94404       {
94405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94406       };
94407     } catch (Dali::DaliException e) {
94408       {
94409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94410       };
94411     } catch (...) {
94412       {
94413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94414       };
94415     }
94416   }
94417
94418   jresult = result;
94419   return jresult;
94420 }
94421
94422
94423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
94424   unsigned int jresult ;
94425   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94426   float arg2 ;
94427   bool arg3 ;
94428   unsigned int result;
94429
94430   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94431   arg2 = (float)jarg2;
94432   arg3 = jarg3 ? true : false;
94433   {
94434     try {
94435       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
94436     } catch (std::out_of_range& e) {
94437       {
94438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94439       };
94440     } catch (std::exception& e) {
94441       {
94442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94443       };
94444     } catch (Dali::DaliException e) {
94445       {
94446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94447       };
94448     } catch (...) {
94449       {
94450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94451       };
94452     }
94453   }
94454
94455   jresult = result;
94456   return jresult;
94457 }
94458
94459
94460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
94461   unsigned int jresult ;
94462   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94463   unsigned int result;
94464
94465   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94466   {
94467     try {
94468       result = (unsigned int)(*arg1)->GetTotalPages();
94469     } catch (std::out_of_range& e) {
94470       {
94471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94472       };
94473     } catch (std::exception& e) {
94474       {
94475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94476       };
94477     } catch (Dali::DaliException e) {
94478       {
94479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94480       };
94481     } catch (...) {
94482       {
94483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94484       };
94485     }
94486   }
94487
94488   jresult = result;
94489   return jresult;
94490 }
94491
94492
94493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
94494   int jresult ;
94495   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94496   Dali::Toolkit::Ruler::RulerType result;
94497
94498   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94499   {
94500     try {
94501       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
94502     } catch (std::out_of_range& e) {
94503       {
94504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94505       };
94506     } catch (std::exception& e) {
94507       {
94508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94509       };
94510     } catch (Dali::DaliException e) {
94511       {
94512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94513       };
94514     } catch (...) {
94515       {
94516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94517       };
94518     }
94519   }
94520
94521   jresult = (int)result;
94522   return jresult;
94523 }
94524
94525
94526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
94527   unsigned int jresult ;
94528   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94529   bool result;
94530
94531   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94532   {
94533     try {
94534       result = (bool)(*arg1)->IsEnabled();
94535     } catch (std::out_of_range& e) {
94536       {
94537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94538       };
94539     } catch (std::exception& e) {
94540       {
94541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94542       };
94543     } catch (Dali::DaliException e) {
94544       {
94545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94546       };
94547     } catch (...) {
94548       {
94549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94550       };
94551     }
94552   }
94553
94554   jresult = result;
94555   return jresult;
94556 }
94557
94558
94559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
94560   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94561
94562   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94563   {
94564     try {
94565       (*arg1)->Enable();
94566     } catch (std::out_of_range& e) {
94567       {
94568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94569       };
94570     } catch (std::exception& e) {
94571       {
94572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94573       };
94574     } catch (Dali::DaliException e) {
94575       {
94576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94577       };
94578     } catch (...) {
94579       {
94580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94581       };
94582     }
94583   }
94584
94585 }
94586
94587
94588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
94589   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94590
94591   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94592   {
94593     try {
94594       (*arg1)->Disable();
94595     } catch (std::out_of_range& e) {
94596       {
94597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94598       };
94599     } catch (std::exception& e) {
94600       {
94601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94602       };
94603     } catch (Dali::DaliException e) {
94604       {
94605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94606       };
94607     } catch (...) {
94608       {
94609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94610       };
94611     }
94612   }
94613
94614 }
94615
94616
94617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
94618   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94619   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
94620   Dali::Toolkit::RulerDomain *argp2 ;
94621
94622   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94623   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
94624   if (!argp2) {
94625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
94626     return ;
94627   }
94628   arg2 = *argp2;
94629   {
94630     try {
94631       (*arg1)->SetDomain(arg2);
94632     } catch (std::out_of_range& e) {
94633       {
94634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94635       };
94636     } catch (std::exception& e) {
94637       {
94638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94639       };
94640     } catch (Dali::DaliException e) {
94641       {
94642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94643       };
94644     } catch (...) {
94645       {
94646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94647       };
94648     }
94649   }
94650
94651 }
94652
94653
94654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
94655   void * jresult ;
94656   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94657   Dali::Toolkit::RulerDomain *result = 0 ;
94658
94659   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94660   {
94661     try {
94662       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
94663     } catch (std::out_of_range& e) {
94664       {
94665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94666       };
94667     } catch (std::exception& e) {
94668       {
94669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94670       };
94671     } catch (Dali::DaliException e) {
94672       {
94673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94674       };
94675     } catch (...) {
94676       {
94677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94678       };
94679     }
94680   }
94681
94682   jresult = (void *)result;
94683   return jresult;
94684 }
94685
94686
94687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
94688   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94689
94690   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94691   {
94692     try {
94693       (*arg1)->DisableDomain();
94694     } catch (std::out_of_range& e) {
94695       {
94696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94697       };
94698     } catch (std::exception& e) {
94699       {
94700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94701       };
94702     } catch (Dali::DaliException e) {
94703       {
94704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94705       };
94706     } catch (...) {
94707       {
94708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94709       };
94710     }
94711   }
94712
94713 }
94714
94715
94716 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
94717   float jresult ;
94718   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94719   float arg2 ;
94720   float arg3 ;
94721   float arg4 ;
94722   float result;
94723
94724   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94725   arg2 = (float)jarg2;
94726   arg3 = (float)jarg3;
94727   arg4 = (float)jarg4;
94728   {
94729     try {
94730       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
94731     } catch (std::out_of_range& e) {
94732       {
94733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94734       };
94735     } catch (std::exception& e) {
94736       {
94737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94738       };
94739     } catch (Dali::DaliException e) {
94740       {
94741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94742       };
94743     } catch (...) {
94744       {
94745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94746       };
94747     }
94748   }
94749
94750   jresult = result;
94751   return jresult;
94752 }
94753
94754
94755 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
94756   float jresult ;
94757   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94758   float arg2 ;
94759   float arg3 ;
94760   float result;
94761
94762   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94763   arg2 = (float)jarg2;
94764   arg3 = (float)jarg3;
94765   {
94766     try {
94767       result = (float)(*arg1)->Clamp(arg2,arg3);
94768     } catch (std::out_of_range& e) {
94769       {
94770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94771       };
94772     } catch (std::exception& e) {
94773       {
94774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94775       };
94776     } catch (Dali::DaliException e) {
94777       {
94778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94779       };
94780     } catch (...) {
94781       {
94782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94783       };
94784     }
94785   }
94786
94787   jresult = result;
94788   return jresult;
94789 }
94790
94791
94792 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
94793   float jresult ;
94794   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94795   float arg2 ;
94796   float result;
94797
94798   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94799   arg2 = (float)jarg2;
94800   {
94801     try {
94802       result = (float)(*arg1)->Clamp(arg2);
94803     } catch (std::out_of_range& e) {
94804       {
94805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94806       };
94807     } catch (std::exception& e) {
94808       {
94809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94810       };
94811     } catch (Dali::DaliException e) {
94812       {
94813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94814       };
94815     } catch (...) {
94816       {
94817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94818       };
94819     }
94820   }
94821
94822   jresult = result;
94823   return jresult;
94824 }
94825
94826
94827 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
94828   float jresult ;
94829   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94830   float arg2 ;
94831   float arg3 ;
94832   float arg4 ;
94833   Dali::Toolkit::ClampState *arg5 = 0 ;
94834   float result;
94835
94836   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94837   arg2 = (float)jarg2;
94838   arg3 = (float)jarg3;
94839   arg4 = (float)jarg4;
94840   arg5 = (Dali::Toolkit::ClampState *)jarg5;
94841   if (!arg5) {
94842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
94843     return 0;
94844   }
94845   {
94846     try {
94847       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
94848     } catch (std::out_of_range& e) {
94849       {
94850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94851       };
94852     } catch (std::exception& e) {
94853       {
94854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94855       };
94856     } catch (Dali::DaliException e) {
94857       {
94858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94859       };
94860     } catch (...) {
94861       {
94862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94863       };
94864     }
94865   }
94866
94867   jresult = result;
94868   return jresult;
94869 }
94870
94871
94872 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
94873   float jresult ;
94874   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94875   float arg2 ;
94876   float arg3 ;
94877   float arg4 ;
94878   float arg5 ;
94879   float result;
94880
94881   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94882   arg2 = (float)jarg2;
94883   arg3 = (float)jarg3;
94884   arg4 = (float)jarg4;
94885   arg5 = (float)jarg5;
94886   {
94887     try {
94888       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
94889     } catch (std::out_of_range& e) {
94890       {
94891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94892       };
94893     } catch (std::exception& e) {
94894       {
94895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94896       };
94897     } catch (Dali::DaliException e) {
94898       {
94899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94900       };
94901     } catch (...) {
94902       {
94903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94904       };
94905     }
94906   }
94907
94908   jresult = result;
94909   return jresult;
94910 }
94911
94912
94913 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
94914   float jresult ;
94915   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94916   float arg2 ;
94917   float arg3 ;
94918   float arg4 ;
94919   float result;
94920
94921   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94922   arg2 = (float)jarg2;
94923   arg3 = (float)jarg3;
94924   arg4 = (float)jarg4;
94925   {
94926     try {
94927       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
94928     } catch (std::out_of_range& e) {
94929       {
94930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94931       };
94932     } catch (std::exception& e) {
94933       {
94934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94935       };
94936     } catch (Dali::DaliException e) {
94937       {
94938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94939       };
94940     } catch (...) {
94941       {
94942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94943       };
94944     }
94945   }
94946
94947   jresult = result;
94948   return jresult;
94949 }
94950
94951
94952 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
94953   float jresult ;
94954   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94955   float arg2 ;
94956   float arg3 ;
94957   float result;
94958
94959   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94960   arg2 = (float)jarg2;
94961   arg3 = (float)jarg3;
94962   {
94963     try {
94964       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
94965     } catch (std::out_of_range& e) {
94966       {
94967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94968       };
94969     } catch (std::exception& e) {
94970       {
94971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94972       };
94973     } catch (Dali::DaliException e) {
94974       {
94975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94976       };
94977     } catch (...) {
94978       {
94979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94980       };
94981     }
94982   }
94983
94984   jresult = result;
94985   return jresult;
94986 }
94987
94988
94989 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
94990   float jresult ;
94991   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94992   float arg2 ;
94993   float result;
94994
94995   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94996   arg2 = (float)jarg2;
94997   {
94998     try {
94999       result = (float)(*arg1)->SnapAndClamp(arg2);
95000     } catch (std::out_of_range& e) {
95001       {
95002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95003       };
95004     } catch (std::exception& e) {
95005       {
95006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95007       };
95008     } catch (Dali::DaliException e) {
95009       {
95010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95011       };
95012     } catch (...) {
95013       {
95014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95015       };
95016     }
95017   }
95018
95019   jresult = result;
95020   return jresult;
95021 }
95022
95023
95024 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
95025   float jresult ;
95026   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95027   float arg2 ;
95028   float arg3 ;
95029   float arg4 ;
95030   float arg5 ;
95031   Dali::Toolkit::ClampState *arg6 = 0 ;
95032   float result;
95033
95034   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95035   arg2 = (float)jarg2;
95036   arg3 = (float)jarg3;
95037   arg4 = (float)jarg4;
95038   arg5 = (float)jarg5;
95039   arg6 = (Dali::Toolkit::ClampState *)jarg6;
95040   if (!arg6) {
95041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
95042     return 0;
95043   }
95044   {
95045     try {
95046       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
95047     } catch (std::out_of_range& e) {
95048       {
95049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95050       };
95051     } catch (std::exception& e) {
95052       {
95053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95054       };
95055     } catch (Dali::DaliException e) {
95056       {
95057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95058       };
95059     } catch (...) {
95060       {
95061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95062       };
95063     }
95064   }
95065
95066   jresult = result;
95067   return jresult;
95068 }
95069
95070
95071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
95072   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95073
95074   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95075   {
95076     try {
95077       (*arg1)->Reference();
95078     } catch (std::out_of_range& e) {
95079       {
95080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95081       };
95082     } catch (std::exception& e) {
95083       {
95084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95085       };
95086     } catch (Dali::DaliException e) {
95087       {
95088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95089       };
95090     } catch (...) {
95091       {
95092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95093       };
95094     }
95095   }
95096
95097 }
95098
95099
95100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
95101   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95102
95103   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95104   {
95105     try {
95106       (*arg1)->Unreference();
95107     } catch (std::out_of_range& e) {
95108       {
95109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95110       };
95111     } catch (std::exception& e) {
95112       {
95113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95114       };
95115     } catch (Dali::DaliException e) {
95116       {
95117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95118       };
95119     } catch (...) {
95120       {
95121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95122       };
95123     }
95124   }
95125
95126 }
95127
95128
95129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
95130   int jresult ;
95131   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95132   int result;
95133
95134   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95135   {
95136     try {
95137       result = (int)(*arg1)->ReferenceCount();
95138     } catch (std::out_of_range& e) {
95139       {
95140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95141       };
95142     } catch (std::exception& e) {
95143       {
95144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95145       };
95146     } catch (Dali::DaliException e) {
95147       {
95148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95149       };
95150     } catch (...) {
95151       {
95152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95153       };
95154     }
95155   }
95156
95157   jresult = result;
95158   return jresult;
95159 }
95160
95161
95162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
95163   unsigned int jresult ;
95164   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95165   bool result;
95166
95167   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95168   {
95169     try {
95170       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95171     } catch (std::out_of_range& e) {
95172       {
95173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95174       };
95175     } catch (std::exception& e) {
95176       {
95177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95178       };
95179     } catch (Dali::DaliException e) {
95180       {
95181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95182       };
95183     } catch (...) {
95184       {
95185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95186       };
95187     }
95188   }
95189
95190   jresult = result;
95191   return jresult;
95192 }
95193
95194
95195 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
95196   unsigned long jresult ;
95197   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95198   std::size_t result;
95199
95200   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95201   {
95202     try {
95203       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95204     } catch (std::out_of_range& e) {
95205       {
95206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95207       };
95208     } catch (std::exception& e) {
95209       {
95210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95211       };
95212     } catch (Dali::DaliException e) {
95213       {
95214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95215       };
95216     } catch (...) {
95217       {
95218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95219       };
95220     }
95221   }
95222
95223   jresult = (unsigned long)result;
95224   return jresult;
95225 }
95226
95227
95228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
95229   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95230   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95231
95232   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95233   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95234   {
95235     try {
95236       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
95237     } catch (std::out_of_range& e) {
95238       {
95239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95240       };
95241     } catch (std::exception& e) {
95242       {
95243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95244       };
95245     } catch (Dali::DaliException e) {
95246       {
95247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95248       };
95249     } catch (...) {
95250       {
95251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95252       };
95253     }
95254   }
95255
95256 }
95257
95258
95259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
95260   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95261   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95262
95263   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95264   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95265   {
95266     try {
95267       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
95268     } catch (std::out_of_range& e) {
95269       {
95270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95271       };
95272     } catch (std::exception& e) {
95273       {
95274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95275       };
95276     } catch (Dali::DaliException e) {
95277       {
95278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95279       };
95280     } catch (...) {
95281       {
95282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95283       };
95284     }
95285   }
95286
95287 }
95288
95289
95290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
95291   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95292   Dali::Toolkit::Control arg2 ;
95293   Dali::Toolkit::Control *argp2 ;
95294
95295   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95296   argp2 = (Dali::Toolkit::Control *)jarg2;
95297   if (!argp2) {
95298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
95299     return ;
95300   }
95301   arg2 = *argp2;
95302   {
95303     try {
95304       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
95305     } catch (std::out_of_range& e) {
95306       {
95307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95308       };
95309     } catch (std::exception& e) {
95310       {
95311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95312       };
95313     } catch (Dali::DaliException e) {
95314       {
95315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95316       };
95317     } catch (...) {
95318       {
95319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95320       };
95321     }
95322   }
95323
95324 }
95325
95326
95327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
95328   void * jresult ;
95329   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
95330
95331   {
95332     try {
95333       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
95334     } catch (std::out_of_range& e) {
95335       {
95336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95337       };
95338     } catch (std::exception& e) {
95339       {
95340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95341       };
95342     } catch (Dali::DaliException e) {
95343       {
95344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95345       };
95346     } catch (...) {
95347       {
95348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95349       };
95350     }
95351   }
95352
95353   jresult = (void *)result;
95354   return jresult;
95355 }
95356
95357
95358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
95359   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95360
95361   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95362   {
95363     try {
95364       delete arg1;
95365     } catch (std::out_of_range& e) {
95366       {
95367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95368       };
95369     } catch (std::exception& e) {
95370       {
95371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95372       };
95373     } catch (Dali::DaliException e) {
95374       {
95375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95376       };
95377     } catch (...) {
95378       {
95379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95380       };
95381     }
95382   }
95383
95384 }
95385
95386 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
95387   Dali::RefObject *result = NULL;
95388
95389   if (arg1)
95390   {
95391     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
95392   }
95393   return result;
95394 }
95395
95396 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
95397     return (Dali::RefObject *)jarg1;
95398 }
95399
95400 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
95401     return (Dali::SignalObserver *)jarg1;
95402 }
95403
95404 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
95405     return (Dali::ConnectionTrackerInterface *)jarg1;
95406 }
95407
95408 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
95409     return (Dali::BaseHandle *)jarg1;
95410 }
95411
95412 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
95413     return (Dali::BaseHandle *)jarg1;
95414 }
95415
95416 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
95417     return (Dali::BaseHandle *)jarg1;
95418 }
95419
95420 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
95421     return (Dali::BaseHandle *)jarg1;
95422 }
95423
95424 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
95425     return (Dali::BaseHandle *)jarg1;
95426 }
95427
95428 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
95429     return (Dali::BaseHandle *)jarg1;
95430 }
95431
95432 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
95433     return (Dali::BaseHandle *)jarg1;
95434 }
95435
95436 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
95437     return (Dali::BaseHandle *)jarg1;
95438 }
95439
95440 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
95441     return (Dali::BaseHandle *)jarg1;
95442 }
95443
95444 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
95445     return (Dali::BaseHandle *)jarg1;
95446 }
95447
95448 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
95449     return (Dali::BaseHandle *)jarg1;
95450 }
95451
95452 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
95453     return (Dali::BaseHandle *)jarg1;
95454 }
95455
95456 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
95457     return (Dali::Handle *)jarg1;
95458 }
95459
95460 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
95461     return (Dali::Handle *)jarg1;
95462 }
95463
95464 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
95465     return (Dali::BaseHandle *)jarg1;
95466 }
95467
95468 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
95469     return (Dali::BaseHandle *)jarg1;
95470 }
95471
95472 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
95473     return (Dali::Handle *)jarg1;
95474 }
95475
95476 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
95477     return (Dali::BaseHandle *)jarg1;
95478 }
95479
95480 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
95481     return (Dali::BaseHandle *)jarg1;
95482 }
95483
95484 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
95485     return (Dali::Handle *)jarg1;
95486 }
95487
95488 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
95489     return (Dali::GestureDetector *)jarg1;
95490 }
95491
95492 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
95493     return (Dali::Gesture *)jarg1;
95494 }
95495
95496 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
95497     return (Dali::Handle *)jarg1;
95498 }
95499
95500 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
95501     return (Dali::Actor *)jarg1;
95502 }
95503
95504 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
95505     return (Dali::RefObject *)jarg1;
95506 }
95507
95508 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
95509     return (Dali::Actor *)jarg1;
95510 }
95511
95512 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
95513     return (Dali::GestureDetector *)jarg1;
95514 }
95515
95516 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
95517     return (Dali::Gesture *)jarg1;
95518 }
95519
95520 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
95521     return (Dali::GestureDetector *)jarg1;
95522 }
95523
95524 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
95525     return (Dali::Gesture *)jarg1;
95526 }
95527
95528 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
95529     return (Dali::GestureDetector *)jarg1;
95530 }
95531
95532 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
95533     return (Dali::Gesture *)jarg1;
95534 }
95535
95536 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
95537     return (Dali::BaseHandle *)jarg1;
95538 }
95539
95540 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
95541     return (Dali::Handle *)jarg1;
95542 }
95543
95544 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
95545     return (Dali::Handle *)jarg1;
95546 }
95547
95548 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
95549     return (Dali::Handle *)jarg1;
95550 }
95551
95552 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
95553     return (Dali::RefObject *)jarg1;
95554 }
95555
95556 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
95557     return (Dali::Actor *)jarg1;
95558 }
95559
95560 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
95561     return (Dali::BaseHandle *)jarg1;
95562 }
95563
95564 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
95565     return (Dali::BaseHandle *)jarg1;
95566 }
95567
95568 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
95569     return (Dali::BaseHandle *)jarg1;
95570 }
95571
95572 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
95573     return (Dali::CustomActorImpl *)jarg1;
95574 }
95575
95576 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
95577     return (Dali::CustomActor *)jarg1;
95578 }
95579
95580 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
95581     return (Dali::BaseHandle *)jarg1;
95582 }
95583
95584 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
95585     return (Dali::Toolkit::Control *)jarg1;
95586 }
95587
95588 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
95589     return (Dali::Toolkit::Control *)jarg1;
95590 }
95591
95592 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
95593     return (Dali::Toolkit::Button *)jarg1;
95594 }
95595
95596 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
95597     return (Dali::Toolkit::Button *)jarg1;
95598 }
95599
95600 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
95601     return (Dali::Toolkit::Button *)jarg1;
95602 }
95603
95604 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
95605     return (Dali::Toolkit::Control *)jarg1;
95606 }
95607
95608 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
95609     return (Dali::Toolkit::Control *)jarg1;
95610 }
95611
95612 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
95613     return (Dali::Toolkit::Control *)jarg1;
95614 }
95615
95616 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
95617     return (Dali::Toolkit::Control *)jarg1;
95618 }
95619
95620 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
95621     return (Dali::Toolkit::Control *)jarg1;
95622 }
95623
95624 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
95625     return (Dali::RefObject *)jarg1;
95626 }
95627
95628 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
95629     return (Dali::Toolkit::Scrollable *)jarg1;
95630 }
95631
95632 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
95633     return (Dali::BaseHandle *)jarg1;
95634 }
95635
95636 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
95637     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
95638 }
95639
95640 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
95641     return (Dali::RefObject *)jarg1;
95642 }
95643
95644 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
95645     return (Dali::Toolkit::Ruler *)jarg1;
95646 }
95647
95648 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
95649     return (Dali::Toolkit::Ruler *)jarg1;
95650 }
95651
95652 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
95653     return (Dali::Toolkit::Scrollable *)jarg1;
95654 }
95655
95656 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
95657     return (Dali::Toolkit::Control *)jarg1;
95658 }
95659
95660
95661 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
95662     return (Dali::Toolkit::Control *)jarg1;
95663 }
95664
95665 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
95666     return (Dali::BaseHandle *)jarg1;
95667 }
95668
95669 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
95670     return (Dali::BaseHandle *)jarg1;
95671 }
95672
95673 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
95674     return (Dali::Toolkit::Control *)jarg1;
95675 }
95676
95677 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
95678     return (Dali::Toolkit::Control *)jarg1;
95679 }
95680
95681 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
95682     return (Dali::Toolkit::Control *)jarg1;
95683 }
95684
95685 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
95686     return (Dali::Toolkit::Control *)jarg1;
95687 }
95688
95689 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
95690     return (Dali::Toolkit::Control *)jarg1;
95691 }
95692
95693 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
95694     return (Dali::Toolkit::Control *)jarg1;
95695 }
95696
95697 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
95698     return (Dali::Toolkit::PageTurnView *)jarg1;
95699 }
95700
95701 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
95702     return (Dali::Toolkit::PageTurnView *)jarg1;
95703 }
95704
95705 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
95706     return (Dali::Toolkit::Button *)jarg1;
95707 }
95708
95709 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
95710     return (Dali::BaseHandle *)jarg1;
95711 }
95712
95713 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
95714     return (Dali::BaseHandle *)jarg1;
95715 }
95716
95717 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
95718     return (Dali::BaseHandle *)jarg1;
95719 }
95720
95721 /*
95722  * Widget binding
95723  */
95724 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
95725     return (Dali::BaseHandle *)jarg1;
95726 }
95727
95728 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
95729     return (Dali::BaseObject *)jarg1;
95730 }
95731
95732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
95733   void * jresult ;
95734   Dali::Widget result;
95735
95736   {
95737     try {
95738       result = Dali::Widget::New();
95739     } catch (std::out_of_range& e) {
95740       {
95741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95742       };
95743     } catch (std::exception& e) {
95744       {
95745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95746       };
95747     } catch (...) {
95748       {
95749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95750       };
95751     }
95752   }
95753   jresult = new Dali::Widget((const Dali::Widget &)result);
95754   return jresult;
95755 }
95756
95757
95758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
95759   void * jresult ;
95760   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
95761   Dali::Widget result;
95762
95763   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95764
95765   if (!arg1) {
95766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
95767     return 0;
95768   }
95769   {
95770     try {
95771       jresult = new Dali::Widget(arg1);
95772     } catch (std::out_of_range& e) {
95773       {
95774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95775       };
95776     } catch (std::exception& e) {
95777       {
95778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95779       };
95780     } catch (...) {
95781       {
95782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95783       };
95784     }
95785   }
95786   return jresult;
95787 }
95788
95789
95790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
95791   void * jresult ;
95792   Dali::Widget *result = 0 ;
95793
95794   {
95795     try {
95796       result = (Dali::Widget *)new Dali::Widget();
95797     } catch (std::out_of_range& e) {
95798       {
95799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95800       };
95801     } catch (std::exception& e) {
95802       {
95803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95804       };
95805     } catch (...) {
95806       {
95807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95808       };
95809     }
95810   }
95811   jresult = (void *)result;
95812   return jresult;
95813 }
95814
95815
95816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
95817   void * jresult ;
95818   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
95819   Dali::Widget *arg2 = 0 ;
95820   Dali::Widget *result = 0 ;
95821
95822   arg1 = (Dali::Widget *)jarg1;
95823   arg2 = (Dali::Widget *)jarg2;
95824   if (!arg2) {
95825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
95826     return 0;
95827   }
95828   {
95829     try {
95830       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
95831     } catch (std::out_of_range& e) {
95832       {
95833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95834       };
95835     } catch (std::exception& e) {
95836       {
95837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95838       };
95839     } catch (...) {
95840       {
95841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95842       };
95843     }
95844   }
95845   jresult = (void *)result;
95846   return jresult;
95847 }
95848
95849
95850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
95851   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
95852
95853   arg1 = (Dali::Widget *)jarg1;
95854   {
95855     try {
95856       delete arg1;
95857     } catch (std::out_of_range& e) {
95858       {
95859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95860       };
95861     } catch (std::exception& e) {
95862       {
95863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95864       };
95865     } catch (...) {
95866       {
95867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95868       };
95869     }
95870   }
95871 }
95872
95873
95874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
95875   void * jresult ;
95876   SwigDirector_WidgetImpl* result;
95877   {
95878     try {
95879       result = new SwigDirector_WidgetImpl();
95880     } catch (std::out_of_range& e) {
95881       {
95882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95883       };
95884     } catch (std::exception& e) {
95885       {
95886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95887       };
95888     } catch (...) {
95889       {
95890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95891       };
95892     }
95893   }
95894   jresult = result;
95895   return jresult;
95896 }
95897
95898
95899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
95900   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95901   std::string *arg2 = 0 ;
95902   Dali::Window arg3 ;
95903   Dali::Window *argp3 ;
95904
95905   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95906   if (!jarg2) {
95907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95908     return ;
95909   }
95910   std::string arg2_str(jarg2);
95911   arg2 = &arg2_str;
95912   argp3 = (Dali::Window *)jarg3;
95913   if (!argp3) {
95914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95915     return ;
95916   }
95917   arg3 = *argp3;
95918   {
95919     try {
95920       (arg1)->OnCreate((std::string const &)*arg2,arg3);
95921     } catch (std::out_of_range& e) {
95922       {
95923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95924       };
95925     } catch (std::exception& e) {
95926       {
95927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95928       };
95929     } catch (...) {
95930       {
95931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95932       };
95933     }
95934   }
95935 }
95936
95937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
95938   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95939   std::string *arg2 = 0 ;
95940   Dali::Window arg3 ;
95941   Dali::Window *argp3 ;
95942
95943   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95944   if (!jarg2) {
95945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95946     return ;
95947   }
95948   std::string arg2_str(jarg2);
95949   arg2 = &arg2_str;
95950   argp3 = (Dali::Window *)jarg3;
95951   if (!argp3) {
95952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95953     return ;
95954   }
95955   arg3 = *argp3;
95956   {
95957     try {
95958       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
95959     } catch (std::out_of_range& e) {
95960       {
95961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95962       };
95963     } catch (std::exception& e) {
95964       {
95965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95966       };
95967     } catch (...) {
95968       {
95969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95970       };
95971     }
95972   }
95973 }
95974
95975
95976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
95977   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95978   std::string *arg2 = 0 ;
95979   Dali::Widget::Termination arg3 ;
95980
95981   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95982   if (!jarg2) {
95983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95984     return ;
95985   }
95986   std::string arg2_str(jarg2);
95987   arg2 = &arg2_str;
95988   arg3 = (Dali::Widget::Termination)jarg3;
95989   {
95990     try {
95991       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
95992     } catch (std::out_of_range& e) {
95993       {
95994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95995       };
95996     } catch (std::exception& e) {
95997       {
95998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95999       };
96000     } catch (...) {
96001       {
96002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96003       };
96004     }
96005   }
96006 }
96007
96008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96009   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96010   std::string *arg2 = 0 ;
96011   Dali::Widget::Termination arg3 ;
96012
96013   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96014   if (!jarg2) {
96015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96016     return ;
96017   }
96018   std::string arg2_str(jarg2);
96019   arg2 = &arg2_str;
96020   arg3 = (Dali::Widget::Termination)jarg3;
96021   {
96022     try {
96023       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
96024     } catch (std::out_of_range& e) {
96025       {
96026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96027       };
96028     } catch (std::exception& e) {
96029       {
96030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96031       };
96032     } catch (...) {
96033       {
96034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96035       };
96036     }
96037   }
96038 }
96039
96040
96041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
96042   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96043
96044   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96045   {
96046     try {
96047       (arg1)->OnPause();
96048     } catch (std::out_of_range& e) {
96049       {
96050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96051       };
96052     } catch (std::exception& e) {
96053       {
96054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96055       };
96056     } catch (...) {
96057       {
96058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96059       };
96060     }
96061   }
96062 }
96063
96064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
96065   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96066
96067   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96068   {
96069     try {
96070       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
96071     } catch (std::out_of_range& e) {
96072       {
96073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96074       };
96075     } catch (std::exception& e) {
96076       {
96077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96078       };
96079     } catch (...) {
96080       {
96081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96082       };
96083     }
96084   }
96085 }
96086
96087
96088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
96089   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96090
96091   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96092   {
96093     try {
96094       (arg1)->OnResume();
96095     } catch (std::out_of_range& e) {
96096       {
96097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96098       };
96099     } catch (std::exception& e) {
96100       {
96101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96102       };
96103     } catch (...) {
96104       {
96105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96106       };
96107     }
96108   }
96109 }
96110
96111
96112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
96113   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96114
96115   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96116   {
96117     try {
96118       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
96119     } catch (std::out_of_range& e) {
96120       {
96121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96122       };
96123     } catch (std::exception& e) {
96124       {
96125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96126       };
96127     } catch (...) {
96128       {
96129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96130       };
96131     }
96132   }
96133 }
96134
96135
96136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
96137   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96138   Dali::Window arg2 ;
96139   Dali::Window *argp2 ;
96140
96141   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96142   argp2 = (Dali::Window *)jarg2;
96143   if (!argp2) {
96144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96145     return ;
96146   }
96147   arg2 = *argp2;
96148   {
96149     try {
96150       (arg1)->OnResize(arg2);
96151     } catch (std::out_of_range& e) {
96152       {
96153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96154       };
96155     } catch (std::exception& e) {
96156       {
96157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96158       };
96159     } catch (...) {
96160       {
96161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96162       };
96163     }
96164   }
96165 }
96166
96167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
96168   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96169   Dali::Window arg2 ;
96170   Dali::Window *argp2 ;
96171
96172   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96173   argp2 = (Dali::Window *)jarg2;
96174   if (!argp2) {
96175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96176     return ;
96177   }
96178   arg2 = *argp2;
96179   {
96180     try {
96181       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
96182     } catch (std::out_of_range& e) {
96183       {
96184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96185       };
96186     } catch (std::exception& e) {
96187       {
96188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96189       };
96190     } catch (...) {
96191       {
96192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96193       };
96194     }
96195   }
96196 }
96197
96198
96199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
96200   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96201   std::string *arg2 = 0 ;
96202   int arg3 ;
96203
96204   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96205   if (!jarg2) {
96206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96207     return ;
96208   }
96209   std::string arg2_str(jarg2);
96210   arg2 = &arg2_str;
96211   arg3 = (int)jarg3;
96212   {
96213     try {
96214       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
96215     } catch (std::out_of_range& e) {
96216       {
96217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96218       };
96219     } catch (std::exception& e) {
96220       {
96221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96222       };
96223     } catch (...) {
96224       {
96225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96226       };
96227     }
96228   }
96229 }
96230
96231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96232   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96233   std::string *arg2 = 0 ;
96234   int arg3 ;
96235
96236   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96237   if (!jarg2) {
96238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96239     return ;
96240   }
96241   std::string arg2_str(jarg2);
96242   arg2 = &arg2_str;
96243   arg3 = (int)jarg3;
96244   {
96245     try {
96246       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
96247     } catch (std::out_of_range& e) {
96248       {
96249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96250       };
96251     } catch (std::exception& e) {
96252       {
96253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96254       };
96255     } catch (...) {
96256       {
96257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96258       };
96259     }
96260   }
96261 }
96262
96263
96264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
96265   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96266   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96267   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96268
96269   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96270   arg2 = (Dali::SlotObserver *)jarg2;
96271   arg3 = (Dali::CallbackBase *)jarg3;
96272   {
96273     try {
96274       (arg1)->SignalConnected(arg2,arg3);
96275     } catch (std::out_of_range& e) {
96276       {
96277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96278       };
96279     } catch (std::exception& e) {
96280       {
96281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96282       };
96283     } catch (...) {
96284       {
96285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96286       };
96287     }
96288   }
96289 }
96290
96291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96292   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96293   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96294   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96295
96296   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96297   arg2 = (Dali::SlotObserver *)jarg2;
96298   arg3 = (Dali::CallbackBase *)jarg3;
96299   {
96300     try {
96301       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
96302     } catch (std::out_of_range& e) {
96303       {
96304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96305       };
96306     } catch (std::exception& e) {
96307       {
96308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96309       };
96310     } catch (...) {
96311       {
96312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96313       };
96314     }
96315   }
96316 }
96317
96318
96319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
96320   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96321   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96322   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96323
96324   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96325   arg2 = (Dali::SlotObserver *)jarg2;
96326   arg3 = (Dali::CallbackBase *)jarg3;
96327   {
96328     try {
96329       (arg1)->SignalDisconnected(arg2,arg3);
96330     } catch (std::out_of_range& e) {
96331       {
96332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96333       };
96334     } catch (std::exception& e) {
96335       {
96336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96337       };
96338     } catch (...) {
96339       {
96340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96341       };
96342     }
96343   }
96344 }
96345
96346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96347   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96348   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96349   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96350
96351   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96352   arg2 = (Dali::SlotObserver *)jarg2;
96353   arg3 = (Dali::CallbackBase *)jarg3;
96354   {
96355     try {
96356       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
96357     } catch (std::out_of_range& e) {
96358       {
96359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96360       };
96361     } catch (std::exception& e) {
96362       {
96363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96364       };
96365     } catch (...) {
96366       {
96367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96368       };
96369     }
96370   }
96371 }
96372
96373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
96374   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96375   std::string *arg2 = 0 ;
96376
96377   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96378   if (!jarg2) {
96379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96380     return ;
96381   }
96382   std::string arg2_str(jarg2);
96383   arg2 = &arg2_str;
96384   {
96385     try {
96386       (arg1)->SetContentInfo((std::string const &)*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
96404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
96405   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96406   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
96407
96408   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96409   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
96410   {
96411     try {
96412       (arg1)->SetImpl(arg2);
96413     } catch (std::out_of_range& e) {
96414       {
96415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96416       };
96417     } catch (std::exception& e) {
96418       {
96419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96420       };
96421     } catch (...) {
96422       {
96423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96424       };
96425     }
96426   }
96427 }
96428
96429 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) {
96430
96431   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
96432   if (director) {
96433     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
96434   }
96435 }
96436
96437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
96438   void * jresult ;
96439   Dali::Widget *arg1 = 0 ;
96440   SwigDirector_WidgetImpl *result = 0 ;
96441
96442   arg1 = (Dali::Widget *)jarg1;
96443   if (!arg1) {
96444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
96445     return 0;
96446   }
96447   {
96448     try {
96449       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
96450     } catch (std::out_of_range& e) {
96451       {
96452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96453       };
96454     } catch (std::exception& e) {
96455       {
96456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96457       };
96458     } catch (...) {
96459       {
96460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96461       };
96462     }
96463   }
96464
96465   jresult = (void *)result;
96466   return jresult;
96467 }
96468
96469
96470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
96471   void * jresult ;
96472   int *arg1 = (int *) 0 ;
96473   char ***arg2 ;
96474   std::string *arg3 = 0 ;
96475   Dali::WidgetApplication result;
96476   {
96477     int index = 0;
96478     int length = 0;
96479     char *retPtr;
96480     char *nextPtr;
96481     argWidgetC = jarg1;
96482     argWidgetV = new char*[jarg1 + 1];
96483
96484     retPtr = strtok_r( jarg2, " ", &nextPtr);
96485     if( retPtr )
96486     {
96487       length = strlen(retPtr);
96488     }
96489     argWidgetV[index] = new char[length + 1];
96490     if( retPtr )
96491     {
96492       strncpy(argWidgetV[index], retPtr, length);
96493     }
96494     argWidgetV[index][length] = '\0';
96495     index++;
96496
96497     while (index < jarg1)
96498     {
96499       length = 0;
96500       retPtr = strtok_r(NULL, " ", &nextPtr);
96501       if( retPtr )
96502       {
96503         length = strlen(retPtr);
96504       }
96505       argWidgetV[index] = new char[length + 1];
96506       if( retPtr )
96507       {
96508         strncpy(argWidgetV[index], retPtr, length);
96509       }
96510       argWidgetV[index][length] = '\0';
96511       index++;
96512     }
96513
96514     argWidgetV[jarg1] = NULL;
96515     argWidgetC = jarg1;
96516
96517     arg1 = &argWidgetC;
96518     arg2 = &argWidgetV;
96519   }
96520
96521   if (!jarg3) {
96522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96523     return 0;
96524   }
96525   std::string arg3_str(jarg3);
96526   arg3 = &arg3_str;
96527   {
96528     try {
96529       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
96530     } catch (std::out_of_range& e) {
96531       {
96532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96533       };
96534     } catch (std::exception& e) {
96535       {
96536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96537       };
96538     } catch (...) {
96539       {
96540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96541       };
96542     }
96543   }
96544   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
96545
96546   return jresult;
96547 }
96548
96549
96550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
96551   void * jresult ;
96552   Dali::WidgetApplication *result = 0 ;
96553
96554   {
96555     try {
96556       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
96557     } catch (std::out_of_range& e) {
96558       {
96559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96560       };
96561     } catch (std::exception& e) {
96562       {
96563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96564       };
96565     } catch (...) {
96566       {
96567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96568       };
96569     }
96570   }
96571   jresult = (void *)result;
96572   return jresult;
96573 }
96574
96575
96576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
96577   void * jresult ;
96578   Dali::WidgetApplication *arg1 = 0 ;
96579   Dali::WidgetApplication *result = 0 ;
96580
96581   arg1 = (Dali::WidgetApplication *)jarg1;
96582   if (!arg1) {
96583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96584     return 0;
96585   }
96586   {
96587     try {
96588       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
96589     } catch (std::out_of_range& e) {
96590       {
96591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96592       };
96593     } catch (std::exception& e) {
96594       {
96595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96596       };
96597     } catch (...) {
96598       {
96599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96600       };
96601     }
96602   }
96603   jresult = (void *)result;
96604   return jresult;
96605 }
96606
96607
96608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
96609   void * jresult ;
96610   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96611   Dali::WidgetApplication *arg2 = 0 ;
96612   Dali::WidgetApplication *result = 0 ;
96613
96614   arg1 = (Dali::WidgetApplication *)jarg1;
96615   arg2 = (Dali::WidgetApplication *)jarg2;
96616   if (!arg2) {
96617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96618     return 0;
96619   }
96620   {
96621     try {
96622       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
96623     } catch (std::out_of_range& e) {
96624       {
96625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96626       };
96627     } catch (std::exception& e) {
96628       {
96629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96630       };
96631     } catch (...) {
96632       {
96633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96634       };
96635     }
96636   }
96637   jresult = (void *)result;
96638   return jresult;
96639 }
96640
96641
96642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
96643   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96644
96645   arg1 = (Dali::WidgetApplication *)jarg1;
96646   {
96647     try {
96648       delete arg1;
96649       if( argWidgetV )
96650       {
96651         // free string data
96652         for( int i=0; i < argWidgetC+1; i++)
96653         {
96654           delete [] argWidgetV[i];
96655         }
96656         delete [] argWidgetV;
96657       }
96658     } catch (std::out_of_range& e) {
96659       {
96660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96661       };
96662     } catch (std::exception& e) {
96663       {
96664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96665       };
96666     } catch (...) {
96667       {
96668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96669       };
96670     }
96671   }
96672 }
96673
96674
96675 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
96676 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
96677
96678 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
96679 {
96680   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
96681   return *widget;
96682 }
96683
96684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
96685   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96686   std::string *arg2 = 0 ;
96687
96688   arg1 = (Dali::WidgetApplication *)jarg1;
96689   if (!jarg2) {
96690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96691     return ;
96692   }
96693   std::string arg2_str(*jarg2);
96694   arg2 = &arg2_str;
96695
96696   if(!_CSharpCreateWidgetFunction)
96697   {
96698     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
96699   }
96700
96701   {
96702     try {
96703       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
96704     } catch (std::out_of_range& e) {
96705       {
96706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96707       };
96708     } catch (std::exception& e) {
96709       {
96710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96711       };
96712     } catch (...) {
96713       {
96714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96715       };
96716     }
96717   }
96718
96719   //Typemap argout in c++ file.
96720   //This will convert c++ string to c# string
96721   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
96722 }
96723
96724
96725 //for PixelBuffer and ImageLoading
96726
96727 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
96728     return (Dali::BaseHandle *)jarg1;
96729 }
96730
96731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
96732   void * jresult ;
96733   unsigned int arg1 ;
96734   unsigned int arg2 ;
96735   Dali::Pixel::Format arg3 ;
96736   Dali::Devel::PixelBuffer result;
96737
96738   arg1 = (unsigned int)jarg1;
96739   arg2 = (unsigned int)jarg2;
96740   arg3 = (Dali::Pixel::Format)jarg3;
96741   {
96742     try {
96743       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
96744     } catch (std::out_of_range& e) {
96745       {
96746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96747       };
96748     } catch (std::exception& e) {
96749       {
96750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96751       };
96752     } catch (...) {
96753       {
96754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96755       };
96756     }
96757   }
96758   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
96759   return jresult;
96760 }
96761
96762
96763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
96764   void * jresult ;
96765   Dali::Devel::PixelBuffer *result = 0 ;
96766
96767   {
96768     try {
96769       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
96770     } catch (std::out_of_range& e) {
96771       {
96772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96773       };
96774     } catch (std::exception& e) {
96775       {
96776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96777       };
96778     } catch (...) {
96779       {
96780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96781       };
96782     }
96783   }
96784   jresult = (void *)result;
96785   return jresult;
96786 }
96787
96788
96789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
96790   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96791
96792   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96793   {
96794     try {
96795       delete arg1;
96796     } catch (std::out_of_range& e) {
96797       {
96798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96799       };
96800     } catch (std::exception& e) {
96801       {
96802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96803       };
96804     } catch (...) {
96805       {
96806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96807       };
96808     }
96809   }
96810 }
96811
96812
96813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
96814   void * jresult ;
96815   Dali::Devel::PixelBuffer *arg1 = 0 ;
96816   Dali::Devel::PixelBuffer *result = 0 ;
96817
96818   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96819   if (!arg1) {
96820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
96821     return 0;
96822   }
96823   {
96824     try {
96825       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
96826     } catch (std::out_of_range& e) {
96827       {
96828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96829       };
96830     } catch (std::exception& e) {
96831       {
96832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96833       };
96834     } catch (...) {
96835       {
96836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96837       };
96838     }
96839   }
96840   jresult = (void *)result;
96841   return jresult;
96842 }
96843
96844
96845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
96846   void * jresult ;
96847   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96848   Dali::Devel::PixelBuffer *arg2 = 0 ;
96849   Dali::Devel::PixelBuffer *result = 0 ;
96850
96851   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96852   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
96853   if (!arg2) {
96854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
96855     return 0;
96856   }
96857   {
96858     try {
96859       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
96860     } catch (std::out_of_range& e) {
96861       {
96862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96863       };
96864     } catch (std::exception& e) {
96865       {
96866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96867       };
96868     } catch (...) {
96869       {
96870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96871       };
96872     }
96873   }
96874   jresult = (void *)result;
96875   return jresult;
96876 }
96877
96878
96879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
96880   void * jresult ;
96881   Dali::Devel::PixelBuffer *arg1 = 0 ;
96882   Dali::PixelData result;
96883
96884   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96885   if (!arg1) {
96886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
96887     return 0;
96888   }
96889   {
96890     try {
96891       result = Dali::Devel::PixelBuffer::Convert(*arg1);
96892     } catch (std::out_of_range& e) {
96893       {
96894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96895       };
96896     } catch (std::exception& e) {
96897       {
96898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96899       };
96900     } catch (...) {
96901       {
96902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96903       };
96904     }
96905   }
96906   jresult = new Dali::PixelData((const Dali::PixelData &)result);
96907   return jresult;
96908 }
96909
96910
96911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
96912   void * jresult ;
96913   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96914   Dali::PixelData result;
96915
96916   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96917   {
96918     try {
96919       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
96920     } catch (std::out_of_range& e) {
96921       {
96922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96923       };
96924     } catch (std::exception& e) {
96925       {
96926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96927       };
96928     } catch (...) {
96929       {
96930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96931       };
96932     }
96933   }
96934   jresult = new Dali::PixelData((const Dali::PixelData &)result);
96935   return jresult;
96936 }
96937
96938
96939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
96940   void * jresult ;
96941   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96942   unsigned char *result = 0 ;
96943
96944   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96945   {
96946     try {
96947       result = (unsigned char *)(arg1)->GetBuffer();
96948     } catch (std::out_of_range& e) {
96949       {
96950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96951       };
96952     } catch (std::exception& e) {
96953       {
96954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96955       };
96956     } catch (...) {
96957       {
96958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96959       };
96960     }
96961   }
96962   jresult = (void *)result;
96963   return jresult;
96964 }
96965
96966
96967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
96968   unsigned int jresult ;
96969   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96970   unsigned int result;
96971
96972   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96973   {
96974     try {
96975       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
96976     } catch (std::out_of_range& e) {
96977       {
96978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96979       };
96980     } catch (std::exception& e) {
96981       {
96982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96983       };
96984     } catch (...) {
96985       {
96986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96987       };
96988     }
96989   }
96990   jresult = result;
96991   return jresult;
96992 }
96993
96994
96995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
96996   unsigned int jresult ;
96997   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96998   unsigned int result;
96999
97000   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97001   {
97002     try {
97003       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
97004     } catch (std::out_of_range& e) {
97005       {
97006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97007       };
97008     } catch (std::exception& e) {
97009       {
97010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97011       };
97012     } catch (...) {
97013       {
97014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97015       };
97016     }
97017   }
97018   jresult = result;
97019   return jresult;
97020 }
97021
97022
97023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
97024   int jresult ;
97025   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97026   Dali::Pixel::Format result;
97027
97028   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97029   {
97030     try {
97031       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
97032     } catch (std::out_of_range& e) {
97033       {
97034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97035       };
97036     } catch (std::exception& e) {
97037       {
97038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97039       };
97040     } catch (...) {
97041       {
97042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97043       };
97044     }
97045   }
97046   jresult = (int)result;
97047   return jresult;
97048 }
97049
97050
97051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
97052   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97053   Dali::Devel::PixelBuffer arg2 ;
97054   float arg3 ;
97055   bool arg4 ;
97056   Dali::Devel::PixelBuffer *argp2 ;
97057
97058   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97059   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97060   if (!argp2) {
97061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97062     return ;
97063   }
97064   arg2 = *argp2;
97065   arg3 = (float)jarg3;
97066   arg4 = jarg4 ? true : false;
97067   {
97068     try {
97069       (arg1)->ApplyMask(arg2,arg3,arg4);
97070     } catch (std::out_of_range& e) {
97071       {
97072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97073       };
97074     } catch (std::exception& e) {
97075       {
97076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97077       };
97078     } catch (...) {
97079       {
97080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97081       };
97082     }
97083   }
97084 }
97085
97086
97087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
97088   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97089   Dali::Devel::PixelBuffer arg2 ;
97090   float arg3 ;
97091   Dali::Devel::PixelBuffer *argp2 ;
97092
97093   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97094   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97095   if (!argp2) {
97096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97097     return ;
97098   }
97099   arg2 = *argp2;
97100   arg3 = (float)jarg3;
97101   {
97102     try {
97103       (arg1)->ApplyMask(arg2,arg3);
97104     } catch (std::out_of_range& e) {
97105       {
97106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97107       };
97108     } catch (std::exception& e) {
97109       {
97110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97111       };
97112     } catch (...) {
97113       {
97114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97115       };
97116     }
97117   }
97118 }
97119
97120
97121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
97122   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97123   Dali::Devel::PixelBuffer arg2 ;
97124   Dali::Devel::PixelBuffer *argp2 ;
97125
97126   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97127   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97128   if (!argp2) {
97129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97130     return ;
97131   }
97132   arg2 = *argp2;
97133   {
97134     try {
97135       (arg1)->ApplyMask(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_ApplyGaussianBlur(void * jarg1, float jarg2) {
97154   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97155   float arg2 ;
97156
97157   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97158   arg2 = (float)jarg2;
97159   {
97160     try {
97161       (arg1)->ApplyGaussianBlur(arg2);
97162     } catch (std::out_of_range& e) {
97163       {
97164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97165       };
97166     } catch (std::exception& e) {
97167       {
97168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97169       };
97170     } catch (...) {
97171       {
97172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97173       };
97174     }
97175   }
97176 }
97177
97178
97179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
97180   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97181   uint16_t arg2 ;
97182   uint16_t arg3 ;
97183   uint16_t arg4 ;
97184   uint16_t arg5 ;
97185
97186   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97187   arg2 = (uint16_t)jarg2;
97188   arg3 = (uint16_t)jarg3;
97189   arg4 = (uint16_t)jarg4;
97190   arg5 = (uint16_t)jarg5;
97191   {
97192     try {
97193       (arg1)->Crop(arg2,arg3,arg4,arg5);
97194     } catch (std::out_of_range& e) {
97195       {
97196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97197       };
97198     } catch (std::exception& e) {
97199       {
97200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97201       };
97202     } catch (...) {
97203       {
97204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97205       };
97206     }
97207   }
97208 }
97209
97210
97211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
97212   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97213   uint16_t arg2 ;
97214   uint16_t arg3 ;
97215
97216   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97217   arg2 = (uint16_t)jarg2;
97218   arg3 = (uint16_t)jarg3;
97219   {
97220     try {
97221       (arg1)->Resize(arg2,arg3);
97222     } catch (std::out_of_range& e) {
97223       {
97224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97225       };
97226     } catch (std::exception& e) {
97227       {
97228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97229       };
97230     } catch (...) {
97231       {
97232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97233       };
97234     }
97235   }
97236 }
97237
97238 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void * jarg2) {
97239   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97240   Dali::Degree * arg2 ;
97241
97242   bool result = false;
97243
97244   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97245   arg2 = (Dali::Degree *)jarg2;
97246   {
97247     try {
97248       result = (arg1)->Rotate(*arg2);
97249     } catch (std::out_of_range& e) {
97250       {
97251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
97252       };
97253     } catch (std::exception& e) {
97254       {
97255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
97256       };
97257     } catch (...) {
97258       {
97259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
97260       };
97261     }
97262   }
97263   return result;
97264 }
97265
97266
97267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97268   void * jresult ;
97269   std::string *arg1 = 0 ;
97270   Dali::ImageDimensions arg2 ;
97271   Dali::FittingMode::Type arg3 ;
97272   Dali::SamplingMode::Type arg4 ;
97273   bool arg5 ;
97274   Dali::ImageDimensions *argp2 ;
97275   Dali::Devel::PixelBuffer result;
97276
97277   if (!jarg1) {
97278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97279     return 0;
97280   }
97281   std::string arg1_str(jarg1);
97282   arg1 = &arg1_str;
97283   argp2 = (Dali::ImageDimensions *)jarg2;
97284   if (!argp2) {
97285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97286     return 0;
97287   }
97288   arg2 = *argp2;
97289   arg3 = (Dali::FittingMode::Type)jarg3;
97290   arg4 = (Dali::SamplingMode::Type)jarg4;
97291   arg5 = jarg5 ? true : false;
97292   {
97293     try {
97294       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97295     } catch (std::out_of_range& e) {
97296       {
97297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97298       };
97299     } catch (std::exception& e) {
97300       {
97301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97302       };
97303     } catch (...) {
97304       {
97305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97306       };
97307     }
97308   }
97309   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97310
97311   return jresult;
97312 }
97313
97314
97315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97316   void * jresult ;
97317   std::string *arg1 = 0 ;
97318   Dali::ImageDimensions arg2 ;
97319   Dali::FittingMode::Type arg3 ;
97320   Dali::SamplingMode::Type arg4 ;
97321   Dali::ImageDimensions *argp2 ;
97322   Dali::Devel::PixelBuffer result;
97323
97324   if (!jarg1) {
97325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97326     return 0;
97327   }
97328   std::string arg1_str(jarg1);
97329   arg1 = &arg1_str;
97330   argp2 = (Dali::ImageDimensions *)jarg2;
97331   if (!argp2) {
97332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97333     return 0;
97334   }
97335   arg2 = *argp2;
97336   arg3 = (Dali::FittingMode::Type)jarg3;
97337   arg4 = (Dali::SamplingMode::Type)jarg4;
97338   {
97339     try {
97340       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
97341     } catch (std::out_of_range& e) {
97342       {
97343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97344       };
97345     } catch (std::exception& e) {
97346       {
97347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97348       };
97349     } catch (...) {
97350       {
97351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97352       };
97353     }
97354   }
97355   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97356
97357   return jresult;
97358 }
97359
97360
97361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97362   void * jresult ;
97363   std::string *arg1 = 0 ;
97364   Dali::ImageDimensions arg2 ;
97365   Dali::FittingMode::Type arg3 ;
97366   Dali::ImageDimensions *argp2 ;
97367   Dali::Devel::PixelBuffer result;
97368
97369   if (!jarg1) {
97370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97371     return 0;
97372   }
97373   std::string arg1_str(jarg1);
97374   arg1 = &arg1_str;
97375   argp2 = (Dali::ImageDimensions *)jarg2;
97376   if (!argp2) {
97377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97378     return 0;
97379   }
97380   arg2 = *argp2;
97381   arg3 = (Dali::FittingMode::Type)jarg3;
97382   {
97383     try {
97384       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
97385     } catch (std::out_of_range& e) {
97386       {
97387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97388       };
97389     } catch (std::exception& e) {
97390       {
97391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97392       };
97393     } catch (...) {
97394       {
97395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97396       };
97397     }
97398   }
97399   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97400
97401   return jresult;
97402 }
97403
97404
97405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
97406   void * jresult ;
97407   std::string *arg1 = 0 ;
97408   Dali::ImageDimensions arg2 ;
97409   Dali::ImageDimensions *argp2 ;
97410   Dali::Devel::PixelBuffer result;
97411
97412   if (!jarg1) {
97413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97414     return 0;
97415   }
97416   std::string arg1_str(jarg1);
97417   arg1 = &arg1_str;
97418   argp2 = (Dali::ImageDimensions *)jarg2;
97419   if (!argp2) {
97420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97421     return 0;
97422   }
97423   arg2 = *argp2;
97424   {
97425     try {
97426       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
97427     } catch (std::out_of_range& e) {
97428       {
97429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97430       };
97431     } catch (std::exception& e) {
97432       {
97433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97434       };
97435     } catch (...) {
97436       {
97437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97438       };
97439     }
97440   }
97441   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97442
97443   return jresult;
97444 }
97445
97446
97447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
97448   void * jresult ;
97449   std::string *arg1 = 0 ;
97450   Dali::Devel::PixelBuffer result;
97451
97452   if (!jarg1) {
97453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97454     return 0;
97455   }
97456   std::string arg1_str(jarg1);
97457   arg1 = &arg1_str;
97458   {
97459     try {
97460       result = Dali::LoadImageFromFile((std::string const &)*arg1);
97461     } catch (std::out_of_range& e) {
97462       {
97463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97464       };
97465     } catch (std::exception& e) {
97466       {
97467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97468       };
97469     } catch (...) {
97470       {
97471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97472       };
97473     }
97474   }
97475   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97476
97477   return jresult;
97478 }
97479
97480
97481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97482   void * jresult ;
97483   std::string *arg1 = 0 ;
97484   Dali::ImageDimensions arg2 ;
97485   Dali::FittingMode::Type arg3 ;
97486   Dali::SamplingMode::Type arg4 ;
97487   bool arg5 ;
97488   Dali::ImageDimensions *argp2 ;
97489   Dali::ImageDimensions result;
97490
97491   if (!jarg1) {
97492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97493     return 0;
97494   }
97495   std::string arg1_str(jarg1);
97496   arg1 = &arg1_str;
97497   argp2 = (Dali::ImageDimensions *)jarg2;
97498   if (!argp2) {
97499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97500     return 0;
97501   }
97502   arg2 = *argp2;
97503   arg3 = (Dali::FittingMode::Type)jarg3;
97504   arg4 = (Dali::SamplingMode::Type)jarg4;
97505   arg5 = jarg5 ? true : false;
97506   {
97507     try {
97508       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97509     } catch (std::out_of_range& e) {
97510       {
97511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97512       };
97513     } catch (std::exception& e) {
97514       {
97515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97516       };
97517     } catch (...) {
97518       {
97519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97520       };
97521     }
97522   }
97523   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97524
97525   return jresult;
97526 }
97527
97528
97529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97530   void * jresult ;
97531   std::string *arg1 = 0 ;
97532   Dali::ImageDimensions arg2 ;
97533   Dali::FittingMode::Type arg3 ;
97534   Dali::SamplingMode::Type arg4 ;
97535   Dali::ImageDimensions *argp2 ;
97536   Dali::ImageDimensions result;
97537
97538   if (!jarg1) {
97539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97540     return 0;
97541   }
97542   std::string arg1_str(jarg1);
97543   arg1 = &arg1_str;
97544   argp2 = (Dali::ImageDimensions *)jarg2;
97545   if (!argp2) {
97546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97547     return 0;
97548   }
97549   arg2 = *argp2;
97550   arg3 = (Dali::FittingMode::Type)jarg3;
97551   arg4 = (Dali::SamplingMode::Type)jarg4;
97552   {
97553     try {
97554       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
97555     } catch (std::out_of_range& e) {
97556       {
97557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97558       };
97559     } catch (std::exception& e) {
97560       {
97561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97562       };
97563     } catch (...) {
97564       {
97565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97566       };
97567     }
97568   }
97569   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97570
97571   return jresult;
97572 }
97573
97574
97575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97576   void * jresult ;
97577   std::string *arg1 = 0 ;
97578   Dali::ImageDimensions arg2 ;
97579   Dali::FittingMode::Type arg3 ;
97580   Dali::ImageDimensions *argp2 ;
97581   Dali::ImageDimensions result;
97582
97583   if (!jarg1) {
97584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97585     return 0;
97586   }
97587   std::string arg1_str(jarg1);
97588   arg1 = &arg1_str;
97589   argp2 = (Dali::ImageDimensions *)jarg2;
97590   if (!argp2) {
97591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97592     return 0;
97593   }
97594   arg2 = *argp2;
97595   arg3 = (Dali::FittingMode::Type)jarg3;
97596   {
97597     try {
97598       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
97599     } catch (std::out_of_range& e) {
97600       {
97601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97602       };
97603     } catch (std::exception& e) {
97604       {
97605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97606       };
97607     } catch (...) {
97608       {
97609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97610       };
97611     }
97612   }
97613   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97614
97615   return jresult;
97616 }
97617
97618
97619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
97620   void * jresult ;
97621   std::string *arg1 = 0 ;
97622   Dali::ImageDimensions arg2 ;
97623   Dali::ImageDimensions *argp2 ;
97624   Dali::ImageDimensions result;
97625
97626   if (!jarg1) {
97627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97628     return 0;
97629   }
97630   std::string arg1_str(jarg1);
97631   arg1 = &arg1_str;
97632   argp2 = (Dali::ImageDimensions *)jarg2;
97633   if (!argp2) {
97634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97635     return 0;
97636   }
97637   arg2 = *argp2;
97638   {
97639     try {
97640       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
97641     } catch (std::out_of_range& e) {
97642       {
97643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97644       };
97645     } catch (std::exception& e) {
97646       {
97647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97648       };
97649     } catch (...) {
97650       {
97651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97652       };
97653     }
97654   }
97655   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97656
97657   return jresult;
97658 }
97659
97660
97661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
97662   void * jresult ;
97663   std::string *arg1 = 0 ;
97664   Dali::ImageDimensions result;
97665
97666   if (!jarg1) {
97667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97668     return 0;
97669   }
97670   std::string arg1_str(jarg1);
97671   arg1 = &arg1_str;
97672   {
97673     try {
97674       result = Dali::GetClosestImageSize((std::string const &)*arg1);
97675     } catch (std::out_of_range& e) {
97676       {
97677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97678       };
97679     } catch (std::exception& e) {
97680       {
97681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97682       };
97683     } catch (...) {
97684       {
97685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97686       };
97687     }
97688   }
97689   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97690
97691   return jresult;
97692 }
97693
97694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
97695   void * jresult ;
97696   std::string *arg1 = 0 ;
97697   Dali::ImageDimensions result;
97698
97699   if (!jarg1) {
97700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97701     return 0;
97702   }
97703   std::string arg1_str(jarg1);
97704   arg1 = &arg1_str;
97705   {
97706     try {
97707       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
97708     } catch (std::out_of_range& e) {
97709       {
97710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97711       };
97712     } catch (std::exception& e) {
97713       {
97714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97715       };
97716     } catch (...) {
97717       {
97718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97719       };
97720     }
97721   }
97722   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97723
97724   return jresult;
97725 }
97726
97727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97728   void * jresult ;
97729   std::string *arg1 = 0 ;
97730   Dali::ImageDimensions arg2 ;
97731   Dali::FittingMode::Type arg3 ;
97732   Dali::SamplingMode::Type arg4 ;
97733   bool arg5 ;
97734   Dali::ImageDimensions *argp2 ;
97735   Dali::Devel::PixelBuffer result;
97736
97737   if (!jarg1) {
97738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97739     return 0;
97740   }
97741   std::string arg1_str(jarg1);
97742   arg1 = &arg1_str;
97743   argp2 = (Dali::ImageDimensions *)jarg2;
97744   if (!argp2) {
97745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97746     return 0;
97747   }
97748   arg2 = *argp2;
97749   arg3 = (Dali::FittingMode::Type)jarg3;
97750   arg4 = (Dali::SamplingMode::Type)jarg4;
97751   arg5 = jarg5 ? true : false;
97752   {
97753     try {
97754       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97755     } catch (std::out_of_range& e) {
97756       {
97757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97758       };
97759     } catch (std::exception& e) {
97760       {
97761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97762       };
97763     } catch (...) {
97764       {
97765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97766       };
97767     }
97768   }
97769   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97770
97771   return jresult;
97772 }
97773
97774
97775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97776   void * jresult ;
97777   std::string *arg1 = 0 ;
97778   Dali::ImageDimensions arg2 ;
97779   Dali::FittingMode::Type arg3 ;
97780   Dali::SamplingMode::Type arg4 ;
97781   Dali::ImageDimensions *argp2 ;
97782   Dali::Devel::PixelBuffer result;
97783
97784   if (!jarg1) {
97785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97786     return 0;
97787   }
97788   std::string arg1_str(jarg1);
97789   arg1 = &arg1_str;
97790   argp2 = (Dali::ImageDimensions *)jarg2;
97791   if (!argp2) {
97792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97793     return 0;
97794   }
97795   arg2 = *argp2;
97796   arg3 = (Dali::FittingMode::Type)jarg3;
97797   arg4 = (Dali::SamplingMode::Type)jarg4;
97798   {
97799     try {
97800       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
97801     } catch (std::out_of_range& e) {
97802       {
97803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97804       };
97805     } catch (std::exception& e) {
97806       {
97807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97808       };
97809     } catch (...) {
97810       {
97811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97812       };
97813     }
97814   }
97815   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97816
97817   return jresult;
97818 }
97819
97820
97821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97822   void * jresult ;
97823   std::string *arg1 = 0 ;
97824   Dali::ImageDimensions arg2 ;
97825   Dali::FittingMode::Type arg3 ;
97826   Dali::ImageDimensions *argp2 ;
97827   Dali::Devel::PixelBuffer result;
97828
97829   if (!jarg1) {
97830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97831     return 0;
97832   }
97833   std::string arg1_str(jarg1);
97834   arg1 = &arg1_str;
97835   argp2 = (Dali::ImageDimensions *)jarg2;
97836   if (!argp2) {
97837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97838     return 0;
97839   }
97840   arg2 = *argp2;
97841   arg3 = (Dali::FittingMode::Type)jarg3;
97842   {
97843     try {
97844       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
97845     } catch (std::out_of_range& e) {
97846       {
97847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97848       };
97849     } catch (std::exception& e) {
97850       {
97851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97852       };
97853     } catch (...) {
97854       {
97855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97856       };
97857     }
97858   }
97859   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97860
97861   return jresult;
97862 }
97863
97864
97865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
97866   void * jresult ;
97867   std::string *arg1 = 0 ;
97868   Dali::ImageDimensions arg2 ;
97869   Dali::ImageDimensions *argp2 ;
97870   Dali::Devel::PixelBuffer result;
97871
97872   if (!jarg1) {
97873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97874     return 0;
97875   }
97876   std::string arg1_str(jarg1);
97877   arg1 = &arg1_str;
97878   argp2 = (Dali::ImageDimensions *)jarg2;
97879   if (!argp2) {
97880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97881     return 0;
97882   }
97883   arg2 = *argp2;
97884   {
97885     try {
97886       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
97887     } catch (std::out_of_range& e) {
97888       {
97889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97890       };
97891     } catch (std::exception& e) {
97892       {
97893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97894       };
97895     } catch (...) {
97896       {
97897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97898       };
97899     }
97900   }
97901   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97902
97903   return jresult;
97904 }
97905
97906
97907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
97908   void * jresult ;
97909   std::string *arg1 = 0 ;
97910   Dali::Devel::PixelBuffer result;
97911
97912   if (!jarg1) {
97913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97914     return 0;
97915   }
97916   std::string arg1_str(jarg1);
97917   arg1 = &arg1_str;
97918   {
97919     try {
97920       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
97921     } catch (std::out_of_range& e) {
97922       {
97923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97924       };
97925     } catch (std::exception& e) {
97926       {
97927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97928       };
97929     } catch (...) {
97930       {
97931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97932       };
97933     }
97934   }
97935   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97936
97937   return jresult;
97938 }
97939
97940
97941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
97942   void * jresult ;
97943   Dali::Toolkit::WebView result;
97944
97945   {
97946     try {
97947       result = Dali::Toolkit::WebView::New();
97948     } catch (std::out_of_range& e) {
97949       {
97950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97951       };
97952     } catch (std::exception& e) {
97953       {
97954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97955       };
97956     } catch (Dali::DaliException e) {
97957       {
97958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97959       };
97960     } catch (...) {
97961       {
97962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97963       };
97964     }
97965   }
97966   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
97967   return jresult;
97968 }
97969
97970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
97971   void * jresult ;
97972   Dali::Toolkit::WebView result;
97973
97974   std::string *arg1;
97975   std::string *arg2;
97976
97977   if (!jarg1) {
97978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
97979     return 0;
97980   }
97981   if (!jarg2) {
97982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
97983     return 0;
97984   }
97985
97986   std::string jarg1_str = std::string(jarg1);
97987   std::string jarg2_str = std::string(jarg2);
97988
97989   arg1 = &jarg1_str;
97990   arg2 = &jarg2_str;
97991
97992   {
97993     try {
97994       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
97995     } catch (std::out_of_range& e) {
97996       {
97997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97998       };
97999     } catch (std::exception& e) {
98000       {
98001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98002       };
98003     } catch (Dali::DaliException e) {
98004       {
98005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98006       };
98007     } catch (...) {
98008       {
98009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98010       };
98011     }
98012   }
98013   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98014   return jresult;
98015 }
98016
98017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
98018   void * jresult ;
98019   Dali::Toolkit::WebView *arg1 = 0 ;
98020   Dali::Toolkit::WebView *result = 0 ;
98021
98022   arg1 = (Dali::Toolkit::WebView *)jarg1;
98023   if (!arg1) {
98024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
98025     return 0;
98026   }
98027   {
98028     try {
98029       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
98030     } catch (std::out_of_range& e) {
98031       {
98032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98033       };
98034     } catch (std::exception& e) {
98035       {
98036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98037       };
98038     } catch (Dali::DaliException e) {
98039       {
98040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98041       };
98042     } catch (...) {
98043       {
98044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98045       };
98046     }
98047   }
98048   jresult = (void *)result;
98049   return jresult;
98050 }
98051
98052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
98053   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98054   arg1 = (Dali::Toolkit::WebView *)jarg1;
98055   {
98056     try {
98057       delete arg1;
98058     } catch (std::out_of_range& e) {
98059       {
98060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98061       };
98062     } catch (std::exception& e) {
98063       {
98064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98065       };
98066     } catch (Dali::DaliException e) {
98067       {
98068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98069       };
98070     } catch (...) {
98071       {
98072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98073       };
98074     }
98075   }
98076 }
98077
98078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
98079   void * jresult ;
98080   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98081   Dali::Toolkit::WebView *arg2 = 0 ;
98082   Dali::Toolkit::WebView *result = 0 ;
98083
98084   arg1 = (Dali::Toolkit::WebView *)jarg1;
98085   arg2 = (Dali::Toolkit::WebView *)jarg2;
98086   if (!arg2) {
98087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
98088     return 0;
98089   }
98090   {
98091     try {
98092       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
98093     } catch (std::out_of_range& e) {
98094       {
98095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98096       };
98097     } catch (std::exception& e) {
98098       {
98099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98100       };
98101     } catch (Dali::DaliException e) {
98102       {
98103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98104       };
98105     } catch (...) {
98106       {
98107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98108       };
98109     }
98110   }
98111   jresult = (void *)result;
98112   return jresult;
98113 }
98114
98115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
98116   void * jresult ;
98117   Dali::BaseHandle arg1 ;
98118   Dali::BaseHandle *argp1 ;
98119   Dali::Toolkit::WebView result;
98120
98121   argp1 = (Dali::BaseHandle *)jarg1;
98122   if (!argp1) {
98123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
98124     return 0;
98125   }
98126   arg1 = *argp1;
98127   {
98128     try {
98129       result = Dali::Toolkit::WebView::DownCast(arg1);
98130     } catch (std::out_of_range& e) {
98131       {
98132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98133       };
98134     } catch (std::exception& e) {
98135       {
98136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98137       };
98138     } catch (Dali::DaliException e) {
98139       {
98140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98141       };
98142     } catch (...) {
98143       {
98144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98145       };
98146     }
98147   }
98148   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98149   return jresult;
98150 }
98151
98152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
98153   return (int) Dali::Toolkit::WebView::Property::URL;
98154 }
98155
98156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
98157   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
98158 }
98159
98160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
98161   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
98162 }
98163
98164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
98165   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
98166 }
98167
98168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
98169   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
98170 }
98171
98172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
98173   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
98174 }
98175
98176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
98177   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
98178 }
98179
98180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
98181   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
98182 }
98183
98184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
98185   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98186   std::string *arg2;
98187
98188   arg1 = (Dali::Toolkit::WebView *)jarg1;
98189
98190   if (!jarg2) {
98191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98192     return;
98193   }
98194
98195   std::string jarg2str = std::string(jarg2);
98196   arg2 = &jarg2str;
98197   {
98198     try {
98199       (arg1)->LoadUrl((std::string const &)*arg2);
98200     } catch (std::out_of_range& e) {
98201       {
98202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98203       };
98204     } catch (std::exception& e) {
98205       {
98206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98207       };
98208     } catch (Dali::DaliException e) {
98209       {
98210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98211       };
98212     } catch (...) {
98213       {
98214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98215       };
98216     }
98217   }
98218 }
98219
98220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
98221   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98222   std::string *arg2;
98223
98224   arg1 = (Dali::Toolkit::WebView *)jarg1;
98225   if (!jarg2) {
98226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98227     return;
98228   }
98229   std::string jarg2str = std::string(jarg2);
98230   arg2 = &jarg2str;
98231   {
98232     try {
98233       (arg1)->LoadHTMLString((std::string const &)*arg2);
98234     } catch (std::out_of_range& e) {
98235       {
98236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98237       };
98238     } catch (std::exception& e) {
98239       {
98240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98241       };
98242     } catch (Dali::DaliException e) {
98243       {
98244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98245       };
98246     } catch (...) {
98247       {
98248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98249       };
98250     }
98251   }
98252 }
98253
98254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
98255   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98256
98257   arg1 = (Dali::Toolkit::WebView *)jarg1;
98258   {
98259     try {
98260       (arg1)->Reload();
98261     } catch (std::out_of_range& e) {
98262       {
98263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98264       };
98265     } catch (std::exception& e) {
98266       {
98267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98268       };
98269     } catch (Dali::DaliException e) {
98270       {
98271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98272       };
98273     } catch (...) {
98274       {
98275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98276       };
98277     }
98278   }
98279 }
98280
98281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
98282   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98283
98284   arg1 = (Dali::Toolkit::WebView *)jarg1;
98285   {
98286     try {
98287       (arg1)->StopLoading();
98288     } catch (std::out_of_range& e) {
98289       {
98290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98291       };
98292     } catch (std::exception& e) {
98293       {
98294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98295       };
98296     } catch (Dali::DaliException e) {
98297       {
98298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98299       };
98300     } catch (...) {
98301       {
98302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98303       };
98304     }
98305   }
98306 }
98307
98308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
98309   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98310
98311   arg1 = (Dali::Toolkit::WebView *)jarg1;
98312   {
98313     try {
98314       (arg1)->Suspend();
98315     } catch (std::out_of_range& e) {
98316       {
98317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98318       };
98319     } catch (std::exception& e) {
98320       {
98321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98322       };
98323     } catch (Dali::DaliException e) {
98324       {
98325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98326       };
98327     } catch (...) {
98328       {
98329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98330       };
98331     }
98332   }
98333 }
98334
98335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
98336   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98337
98338   arg1 = (Dali::Toolkit::WebView *)jarg1;
98339   {
98340     try {
98341       (arg1)->Resume();
98342     } catch (std::out_of_range& e) {
98343       {
98344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98345       };
98346     } catch (std::exception& e) {
98347       {
98348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98349       };
98350     } catch (Dali::DaliException e) {
98351       {
98352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98353       };
98354     } catch (...) {
98355       {
98356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98357       };
98358     }
98359   }
98360 }
98361
98362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
98363   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98364
98365   arg1 = (Dali::Toolkit::WebView *)jarg1;
98366   {
98367     try {
98368       (arg1)->GoBack();
98369     } catch (std::out_of_range& e) {
98370       {
98371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98372       };
98373     } catch (std::exception& e) {
98374       {
98375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98376       };
98377     } catch (Dali::DaliException e) {
98378       {
98379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98380       };
98381     } catch (...) {
98382       {
98383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98384       };
98385     }
98386   }
98387 }
98388
98389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
98390   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98391
98392   arg1 = (Dali::Toolkit::WebView *)jarg1;
98393   {
98394     try {
98395       (arg1)->GoForward();
98396     } catch (std::out_of_range& e) {
98397       {
98398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98399       };
98400     } catch (std::exception& e) {
98401       {
98402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98403       };
98404     } catch (Dali::DaliException e) {
98405       {
98406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98407       };
98408     } catch (...) {
98409       {
98410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98411       };
98412     }
98413   }
98414 }
98415
98416 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
98417   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98418   bool ret;
98419
98420   arg1 = (Dali::Toolkit::WebView *)jarg1;
98421   {
98422     try {
98423       ret = (arg1)->CanGoBack();
98424     } catch (std::out_of_range& e) {
98425       {
98426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98427       };
98428     } catch (std::exception& e) {
98429       {
98430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98431       };
98432     } catch (Dali::DaliException e) {
98433       {
98434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98435       };
98436     } catch (...) {
98437       {
98438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98439       };
98440     }
98441   }
98442   return ret;
98443 }
98444
98445 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
98446   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98447   bool ret;
98448
98449   arg1 = (Dali::Toolkit::WebView *)jarg1;
98450   {
98451     try {
98452       ret = (arg1)->CanGoForward();
98453     } catch (std::out_of_range& e) {
98454       {
98455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98456       };
98457     } catch (std::exception& e) {
98458       {
98459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98460       };
98461     } catch (Dali::DaliException e) {
98462       {
98463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98464       };
98465     } catch (...) {
98466       {
98467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98468       };
98469     }
98470   }
98471   return ret;
98472 }
98473
98474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
98475   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98476   std::string *arg2;
98477
98478   arg1 = (Dali::Toolkit::WebView *)jarg1;
98479   if (!jarg2) {
98480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98481     return;
98482   }
98483   std::string jarg2_str = std::string(jarg2);
98484   arg2 = &jarg2_str;
98485
98486   {
98487     try {
98488       if (jarg3) {
98489         void (*handler)(char*) = (void (*)(char*)) jarg3;
98490         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
98491           handler(SWIG_csharp_string_callback(result.c_str()));
98492         });
98493       } else {
98494         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
98495       }
98496     } catch (std::out_of_range& e) {
98497       {
98498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98499       };
98500     } catch (std::exception& e) {
98501       {
98502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98503       };
98504     } catch (Dali::DaliException e) {
98505       {
98506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98507       };
98508     } catch (...) {
98509       {
98510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98511       };
98512     }
98513   }
98514 }
98515
98516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
98517 {
98518   if (!jarg2) {
98519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98520     return;
98521   }
98522
98523   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98524   std::string exposedObjectName = jarg2;
98525   void (*handler)(char*) = (void (*)(char*)) jarg3;
98526
98527   {
98528     try {
98529       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
98530         handler(SWIG_csharp_string_callback(message.c_str()));
98531       });
98532     } catch (std::out_of_range& e) {
98533       {
98534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98535       };
98536     } catch (std::exception& e) {
98537       {
98538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98539       };
98540     } catch (Dali::DaliException e) {
98541       {
98542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98543       };
98544     } catch (...) {
98545       {
98546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98547       };
98548     }
98549   }
98550 }
98551
98552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
98553   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98554
98555   arg1 = (Dali::Toolkit::WebView *)jarg1;
98556   {
98557     try {
98558       (arg1)->ClearHistory();
98559     } catch (std::out_of_range& e) {
98560       {
98561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98562       };
98563     } catch (std::exception& e) {
98564       {
98565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98566       };
98567     } catch (Dali::DaliException e) {
98568       {
98569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98570       };
98571     } catch (...) {
98572       {
98573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98574       };
98575     }
98576   }
98577 }
98578
98579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
98580   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98581
98582   arg1 = (Dali::Toolkit::WebView *)jarg1;
98583   {
98584     try {
98585       (arg1)->ClearCache();
98586     } catch (std::out_of_range& e) {
98587       {
98588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98589       };
98590     } catch (std::exception& e) {
98591       {
98592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98593       };
98594     } catch (Dali::DaliException e) {
98595       {
98596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98597       };
98598     } catch (...) {
98599       {
98600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98601       };
98602     }
98603   }
98604 }
98605
98606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
98607   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98608
98609   arg1 = (Dali::Toolkit::WebView *)jarg1;
98610   {
98611     try {
98612       (arg1)->ClearCookies();
98613     } catch (std::out_of_range& e) {
98614       {
98615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98616       };
98617     } catch (std::exception& e) {
98618       {
98619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98620       };
98621     } catch (Dali::DaliException e) {
98622       {
98623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98624       };
98625     } catch (...) {
98626       {
98627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98628       };
98629     }
98630   }
98631 }
98632
98633 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
98634     return (Dali::Toolkit::Control *)jarg1;
98635 }
98636
98637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
98638   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98639   SignalConverter::WebViewPageLoadSignal* result = NULL;
98640   {
98641     try {
98642       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
98643     } catch (std::out_of_range& e) {
98644       {
98645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98646       };
98647     } catch (std::exception& e) {
98648       {
98649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98650       };
98651     } catch (Dali::DaliException e) {
98652       {
98653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98654       };
98655     } catch (...) {
98656       {
98657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98658       };
98659     }
98660   }
98661   return (void*) result;
98662 }
98663
98664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
98665   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98666   SignalConverter::WebViewPageLoadSignal* result = NULL;
98667   {
98668     try {
98669       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
98670     } catch (std::out_of_range& e) {
98671       {
98672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98673       };
98674     } catch (std::exception& e) {
98675       {
98676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98677       };
98678     } catch (Dali::DaliException e) {
98679       {
98680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98681       };
98682     } catch (...) {
98683       {
98684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98685       };
98686     }
98687   }
98688   return (void*) result;
98689 }
98690
98691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
98692 {
98693   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98694   {
98695     try {
98696       delete object;
98697     } catch (std::out_of_range& e) {
98698       {
98699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98700       };
98701     } catch (std::exception& e) {
98702       {
98703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98704       };
98705     } catch (Dali::DaliException e) {
98706       {
98707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98708       };
98709     } catch (...) {
98710       {
98711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98712       };
98713     }
98714   }
98715 }
98716
98717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
98718 {
98719   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98720   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98721   {
98722     try {
98723       proxy->Connect(callback);
98724     } catch (std::out_of_range& e) {
98725       {
98726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98727       };
98728     } catch (std::exception& e) {
98729       {
98730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98731       };
98732     } catch (Dali::DaliException e) {
98733       {
98734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98735       };
98736     } catch (...) {
98737       {
98738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98739       };
98740     }
98741   }
98742 }
98743
98744
98745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
98746   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98747   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98748   {
98749     try {
98750       proxy->Disconnect(callback);
98751     } catch (std::out_of_range& e) {
98752       {
98753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98754       };
98755     } catch (std::exception& e) {
98756       {
98757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98758       };
98759     } catch (Dali::DaliException e) {
98760       {
98761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98762       };
98763     } catch (...) {
98764       {
98765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98766       };
98767     }
98768   }
98769 }
98770
98771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
98772   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98773   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
98774   {
98775     try {
98776       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
98777     } catch (std::out_of_range& e) {
98778       {
98779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98780       };
98781     } catch (std::exception& e) {
98782       {
98783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98784       };
98785     } catch (Dali::DaliException e) {
98786       {
98787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98788       };
98789     } catch (...) {
98790       {
98791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98792       };
98793     }
98794   }
98795   return (void*) result;
98796 }
98797
98798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
98799 {
98800   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98801   {
98802     try {
98803       delete object;
98804     } catch (std::out_of_range& e) {
98805       {
98806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98807       };
98808     } catch (std::exception& e) {
98809       {
98810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98811       };
98812     } catch (Dali::DaliException e) {
98813       {
98814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98815       };
98816     } catch (...) {
98817       {
98818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98819       };
98820     }
98821   }
98822 }
98823
98824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
98825 {
98826   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98827   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
98828   {
98829     try {
98830       proxy->Connect(callback);
98831     } catch (std::out_of_range& e) {
98832       {
98833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98834       };
98835     } catch (std::exception& e) {
98836       {
98837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98838       };
98839     } catch (Dali::DaliException e) {
98840       {
98841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98842       };
98843     } catch (...) {
98844       {
98845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98846       };
98847     }
98848   }
98849 }
98850
98851
98852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
98853   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98854   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
98855   {
98856     try {
98857       proxy->Disconnect(callback);
98858     } catch (std::out_of_range& e) {
98859       {
98860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98861       };
98862     } catch (std::exception& e) {
98863       {
98864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98865       };
98866     } catch (Dali::DaliException e) {
98867       {
98868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98869       };
98870     } catch (...) {
98871       {
98872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98873       };
98874     }
98875   }
98876 }
98877
98878 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
98879   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
98880   char * jresult = SWIG_csharp_string_callback((const char *)result);
98881   return jresult;
98882 }
98883
98884 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
98885   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
98886   return result;
98887 }
98888
98889
98890 struct NativeImageSourcePtrHandle
98891 {
98892   NativeImageSourcePtr Ptr;
98893 };
98894
98895 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
98896 {
98897   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98898   return (NativeImageInterface*)(arg1);
98899 }
98900
98901 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
98902 {
98903   void* jresult;
98904   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
98905   {
98906     try {
98907       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
98908     }
98909     catch (std::out_of_range & e) {
98910       {
98911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98912       };
98913     }
98914     catch (std::exception & e) {
98915       {
98916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98917       };
98918     }
98919     catch (Dali::DaliException e) {
98920       {
98921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98922       };
98923     }
98924     catch (...) {
98925       {
98926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98927       };
98928     }
98929   }
98930   jresult = (void *)handle;
98931   return jresult;
98932 }
98933
98934 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
98935 {
98936   void* jresult;
98937   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
98938   jresult = (void*)( handle->Ptr.Get() );
98939   return jresult;
98940 }
98941
98942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
98943   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
98944   {
98945     try {
98946       delete arg1;
98947     }
98948     catch (std::out_of_range & e) {
98949       {
98950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
98951       };
98952     }
98953     catch (std::exception & e) {
98954       {
98955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
98956       };
98957     }
98958     catch (Dali::DaliException e) {
98959       {
98960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
98961       };
98962     }
98963     catch (...) {
98964       {
98965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
98966       };
98967     }
98968   }
98969 }
98970
98971 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
98972 {
98973   void* jresult;
98974   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98975   uint16_t* arg2 = (uint16_t*)(jarg2);
98976   uint16_t* arg3 = (uint16_t*)(jarg3);
98977   uint16_t* arg4 = (uint16_t*)(jarg4);
98978   {
98979     try {
98980       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
98981     }
98982     catch (std::out_of_range & e) {
98983       {
98984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98985       };
98986     }
98987     catch (std::exception & e) {
98988       {
98989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98990       };
98991     }
98992     catch (Dali::DaliException e) {
98993       {
98994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98995       };
98996     }
98997     catch (...) {
98998       {
98999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99000       };
99001     }
99002   }
99003   return jresult;
99004 }
99005
99006 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
99007 {
99008   bool jresult;
99009   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99010
99011   {
99012     try {
99013       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
99014     }
99015     catch (std::out_of_range & e) {
99016       {
99017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99018       };
99019     }
99020     catch (std::exception & e) {
99021       {
99022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99023       };
99024     }
99025     catch (Dali::DaliException e) {
99026       {
99027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99028       };
99029     }
99030     catch (...) {
99031       {
99032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99033       };
99034     }
99035   }
99036   return jresult;
99037 }
99038
99039
99040 #ifdef __cplusplus
99041 }
99042 #endif