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::OnAccessibilityValueChange(bool isIncrease) {
2143   bool c_result = SwigValueInit< bool >() ;
2144   unsigned int jresult = 0 ;
2145   unsigned int jisIncrease  ;
2146
2147   if (!swig_callbackOnAccessibilityValueChange) {
2148     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2149   } else {
2150     jisIncrease = isIncrease;
2151     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2152     c_result = jresult ? true : false;
2153   }
2154   return c_result;
2155 }
2156
2157 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2158   bool c_result = SwigValueInit< bool >() ;
2159   unsigned int jresult = 0 ;
2160
2161   if (!swig_callbackOnAccessibilityZoom) {
2162     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2163   } else {
2164     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2165     c_result = jresult ? true : false;
2166   }
2167   return c_result;
2168 }
2169
2170 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2171   if (!swig_callbackOnKeyInputFocusGained) {
2172     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2173     return;
2174   } else {
2175     swig_callbackOnKeyInputFocusGained();
2176   }
2177 }
2178
2179 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2180   if (!swig_callbackOnKeyInputFocusLost) {
2181     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2182     return;
2183   } else {
2184     swig_callbackOnKeyInputFocusLost();
2185   }
2186 }
2187
2188 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2189   Dali::Actor c_result ;
2190   void * jresult = 0 ;
2191   void * jcurrentFocusedActor  ;
2192   int jdirection  ;
2193   unsigned int jloopEnabled  ;
2194
2195   if (!swig_callbackGetNextKeyboardFocusableActor) {
2196     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2197   } else {
2198     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2199     jdirection = (int)direction;
2200     jloopEnabled = loopEnabled;
2201     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2202     if (!jresult) {
2203       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2204       return c_result;
2205     }
2206     c_result = *(Dali::Actor *)jresult;
2207   }
2208   return c_result;
2209 }
2210
2211 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2212   void * jcommitedFocusableActor  ;
2213
2214   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2215     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2216     return;
2217   } else {
2218     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2219     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2220   }
2221 }
2222
2223 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2224   bool c_result = SwigValueInit< bool >() ;
2225   unsigned int jresult = 0 ;
2226
2227   if (!swig_callbackOnKeyboardEnter) {
2228     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2229   } else {
2230     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2231     c_result = jresult ? true : false;
2232   }
2233   return c_result;
2234 }
2235
2236 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2237   void * jpinch = 0 ;
2238
2239   if (!swig_callbackOnPinch) {
2240     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2241     return;
2242   } else {
2243     jpinch = (Dali::PinchGesture *) &pinch;
2244     swig_callbackOnPinch(jpinch);
2245   }
2246 }
2247
2248 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2249   void * jpan = 0 ;
2250
2251   if (!swig_callbackOnPan) {
2252     Dali::Toolkit::Internal::Control::OnPan(pan);
2253     return;
2254   } else {
2255     jpan = (Dali::PanGesture *) &pan;
2256     swig_callbackOnPan(jpan);
2257   }
2258 }
2259
2260 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2261   void * jtap = 0 ;
2262
2263   if (!swig_callbackOnTap) {
2264     Dali::Toolkit::Internal::Control::OnTap(tap);
2265     return;
2266   } else {
2267     jtap = (Dali::TapGesture *) &tap;
2268     swig_callbackOnTap(jtap);
2269   }
2270 }
2271
2272 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2273   void * jlongPress = 0 ;
2274
2275   if (!swig_callbackOnLongPress) {
2276     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2277     return;
2278   } else {
2279     jlongPress = (Dali::LongPressGesture *) &longPress;
2280     swig_callbackOnLongPress(jlongPress);
2281   }
2282 }
2283
2284 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2285   void * jslotObserver = 0 ;
2286   void * jcallback = 0 ;
2287
2288   if (!swig_callbackSignalConnected) {
2289     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2290     return;
2291   } else {
2292     jslotObserver = (void *) slotObserver;
2293     jcallback = (void *) callback;
2294     swig_callbackSignalConnected(jslotObserver, jcallback);
2295   }
2296 }
2297
2298 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2299   void * jslotObserver = 0 ;
2300   void * jcallback = 0 ;
2301
2302   if (!swig_callbackSignalDisconnected) {
2303     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2304     return;
2305   } else {
2306     jslotObserver = (void *) slotObserver;
2307     jcallback = (void *) callback;
2308     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2309   }
2310 }
2311
2312 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2313   return Dali::Toolkit::Internal::Control::GetControlExtension();
2314 }
2315
2316 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnSceneConnection, SWIG_Callback1_t callbackOnSceneDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2317   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2318   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2319   swig_callbackOnChildAdd = callbackOnChildAdd;
2320   swig_callbackOnChildRemove = callbackOnChildRemove;
2321   swig_callbackOnPropertySet = callbackOnPropertySet;
2322   swig_callbackOnSizeSet = callbackOnSizeSet;
2323   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2324   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2325   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2326   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2327   swig_callbackOnRelayout = callbackOnRelayout;
2328   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2329   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2330   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2331   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2332   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2333   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2334   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2335   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2336   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2337   swig_callbackOnInitialize = callbackOnInitialize;
2338   swig_callbackOnStyleChange = callbackOnStyleChange;
2339   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2340   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2341   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2342   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2343   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2344   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2345   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2346   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2347   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2348   swig_callbackOnPinch = callbackOnPinch;
2349   swig_callbackOnPan = callbackOnPan;
2350   swig_callbackOnTap = callbackOnTap;
2351   swig_callbackOnLongPress = callbackOnLongPress;
2352   swig_callbackSignalConnected = callbackSignalConnected;
2353   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2354 }
2355
2356 void SwigDirector_ViewImpl::swig_init_callbacks() {
2357   swig_callbackOnSceneConnection = 0;
2358   swig_callbackOnSceneDisconnection = 0;
2359   swig_callbackOnChildAdd = 0;
2360   swig_callbackOnChildRemove = 0;
2361   swig_callbackOnPropertySet = 0;
2362   swig_callbackOnSizeSet = 0;
2363   swig_callbackOnSizeAnimation = 0;
2364   swig_callbackOnHoverEvent = 0;
2365   swig_callbackOnKeyEvent = 0;
2366   swig_callbackOnWheelEvent = 0;
2367   swig_callbackOnRelayout = 0;
2368   swig_callbackOnSetResizePolicy = 0;
2369   swig_callbackGetNaturalSize = 0;
2370   swig_callbackCalculateChildSize = 0;
2371   swig_callbackGetHeightForWidth = 0;
2372   swig_callbackGetWidthForHeight = 0;
2373   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2374   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2375   swig_callbackOnCalculateRelayoutSize = 0;
2376   swig_callbackOnLayoutNegotiated = 0;
2377   swig_callbackOnInitialize = 0;
2378   swig_callbackOnStyleChange = 0;
2379   swig_callbackOnAccessibilityActivated = 0;
2380   swig_callbackOnAccessibilityPan = 0;
2381   swig_callbackOnAccessibilityValueChange = 0;
2382   swig_callbackOnAccessibilityZoom = 0;
2383   swig_callbackOnKeyInputFocusGained = 0;
2384   swig_callbackOnKeyInputFocusLost = 0;
2385   swig_callbackGetNextKeyboardFocusableActor = 0;
2386   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2387   swig_callbackOnKeyboardEnter = 0;
2388   swig_callbackOnPinch = 0;
2389   swig_callbackOnPan = 0;
2390   swig_callbackOnTap = 0;
2391   swig_callbackOnLongPress = 0;
2392   swig_callbackSignalConnected = 0;
2393   swig_callbackSignalDisconnected = 0;
2394 }
2395
2396 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2397   swig_init_callbacks();
2398 }
2399
2400 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2401
2402 }
2403
2404
2405 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2406   unsigned int c_result = SwigValueInit< unsigned int >() ;
2407   unsigned int jresult = 0 ;
2408
2409   if (!swig_callbackGetNumberOfItems) {
2410     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2411   } else {
2412     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2413     c_result = (unsigned int)jresult;
2414   }
2415   return c_result;
2416 }
2417
2418 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2419   Dali::Actor c_result ;
2420   void * jresult = 0 ;
2421   unsigned int jitemId  ;
2422
2423   if (!swig_callbackNewItem) {
2424     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2425   } else {
2426     jitemId = itemId;
2427     jresult = (void *) swig_callbackNewItem(jitemId);
2428     if (!jresult) {
2429       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2430       return c_result;
2431     }
2432     c_result = *(Dali::Actor *)jresult;
2433   }
2434   return c_result;
2435 }
2436
2437 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2438   unsigned int jitemId  ;
2439   void * jactor  ;
2440
2441   if (!swig_callbackItemReleased) {
2442     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2443     return;
2444   } else {
2445     jitemId = itemId;
2446     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2447     swig_callbackItemReleased(jitemId, jactor);
2448   }
2449 }
2450
2451 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2452   return Dali::Toolkit::ItemFactory::GetExtension();
2453 }
2454
2455 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2456   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2457   swig_callbackNewItem = callbackNewItem;
2458   swig_callbackItemReleased = callbackItemReleased;
2459 }
2460
2461 void SwigDirector_ItemFactory::swig_init_callbacks() {
2462   swig_callbackGetNumberOfItems = 0;
2463   swig_callbackNewItem = 0;
2464   swig_callbackItemReleased = 0;
2465 }
2466
2467 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2468   swig_init_callbacks();
2469 }
2470
2471 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2472
2473 }
2474
2475
2476 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2477   Dali::Actor c_result ;
2478   void * jresult = 0 ;
2479   void * jcurrent  ;
2480   void * jproposed  ;
2481   int jdirection  ;
2482
2483   if (!swig_callbackGetNextFocusableActor) {
2484     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2485   } else {
2486     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2487     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2488     jdirection = (int)direction;
2489     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2490     if (!jresult) {
2491       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__);
2492       return c_result;
2493     }
2494     c_result = *(Dali::Actor *)jresult;
2495   }
2496   return c_result;
2497 }
2498
2499 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2500   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2501 }
2502
2503 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2504   swig_callbackGetNextFocusableActor = 0;
2505 }
2506
2507 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
2508   swig_callbackOnUpdate = 0;
2509 }
2510
2511 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
2512
2513 }
2514
2515 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
2516   swig_callbackOnUpdate = callbackUpdate;
2517 }
2518
2519
2520 void SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
2521   void * jcurrent  ;
2522
2523   if (!swig_callbackOnUpdate) {
2524     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2525   } else {
2526     Dali::UpdateProxy* proxy = &updateProxy;
2527     jcurrent = (void *)proxy;
2528     swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2529     if (!jcurrent) {
2530       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2531       return;
2532     }
2533   }
2534   return;
2535 }
2536
2537
2538 #ifdef __cplusplus
2539 extern "C" {
2540 #endif
2541
2542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2543   void * jresult ;
2544   floatp *result = 0 ;
2545
2546   {
2547     try {
2548       result = (floatp *)new_floatp();
2549     } catch (std::out_of_range& e) {
2550       {
2551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2552       };
2553     } catch (std::exception& e) {
2554       {
2555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2556       };
2557     } catch (DaliException e) {
2558       {
2559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2560       };
2561     } catch (...) {
2562       {
2563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2564       };
2565     }
2566   }
2567   jresult = (void *)result;
2568   return jresult;
2569 }
2570
2571
2572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2573   floatp *arg1 = (floatp *) 0 ;
2574
2575   arg1 = (floatp *)jarg1;
2576   {
2577     try {
2578       delete_floatp(arg1);
2579     } catch (std::out_of_range& e) {
2580       {
2581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2582       };
2583     } catch (std::exception& e) {
2584       {
2585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2586       };
2587     } catch (Dali::DaliException e) {
2588       {
2589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2590       };
2591     } catch (...) {
2592       {
2593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2594       };
2595     }
2596   }
2597
2598 }
2599
2600
2601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2602   floatp *arg1 = (floatp *) 0 ;
2603   float arg2 ;
2604
2605   arg1 = (floatp *)jarg1;
2606   arg2 = (float)jarg2;
2607   {
2608     try {
2609       floatp_assign(arg1,arg2);
2610     } catch (std::out_of_range& e) {
2611       {
2612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2613       };
2614     } catch (std::exception& e) {
2615       {
2616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2617       };
2618     } catch (Dali::DaliException e) {
2619       {
2620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2621       };
2622     } catch (...) {
2623       {
2624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2625       };
2626     }
2627   }
2628
2629 }
2630
2631
2632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2633   float jresult ;
2634   floatp *arg1 = (floatp *) 0 ;
2635   float result;
2636
2637   arg1 = (floatp *)jarg1;
2638   {
2639     try {
2640       result = (float)floatp_value(arg1);
2641     } catch (std::out_of_range& e) {
2642       {
2643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2644       };
2645     } catch (std::exception& e) {
2646       {
2647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2648       };
2649     } catch (DaliException e) {
2650       {
2651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2652       };
2653     } catch (...) {
2654       {
2655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2656       };
2657     }
2658   }
2659   jresult = result;
2660   return jresult;
2661 }
2662
2663
2664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2665   void * jresult ;
2666   floatp *arg1 = (floatp *) 0 ;
2667   float *result = 0 ;
2668
2669   arg1 = (floatp *)jarg1;
2670   {
2671     try {
2672       result = (float *)floatp_cast(arg1);
2673     } catch (std::out_of_range& e) {
2674       {
2675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2676       };
2677     } catch (std::exception& e) {
2678       {
2679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2680       };
2681     } catch (Dali::DaliException e) {
2682       {
2683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2684       };
2685     } catch (...) {
2686       {
2687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2688       };
2689     }
2690   }
2691
2692   jresult = (void *)result;
2693   return jresult;
2694 }
2695
2696
2697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2698   void * jresult ;
2699   float *arg1 = (float *) 0 ;
2700   floatp *result = 0 ;
2701
2702   arg1 = (float *)jarg1;
2703   {
2704     try {
2705       result = (floatp *)floatp_frompointer(arg1);
2706     } catch (std::out_of_range& e) {
2707       {
2708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2709       };
2710     } catch (std::exception& e) {
2711       {
2712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2713       };
2714     } catch (Dali::DaliException e) {
2715       {
2716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2717       };
2718     } catch (...) {
2719       {
2720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2721       };
2722     }
2723   }
2724
2725   jresult = (void *)result;
2726   return jresult;
2727 }
2728
2729
2730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2731   void * jresult ;
2732   intp *result = 0 ;
2733
2734   {
2735     try {
2736       result = (intp *)new_intp();
2737     } catch (std::out_of_range& e) {
2738       {
2739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2740       };
2741     } catch (std::exception& e) {
2742       {
2743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2744       };
2745     } catch (Dali::DaliException e) {
2746       {
2747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2748       };
2749     } catch (...) {
2750       {
2751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2752       };
2753     }
2754   }
2755
2756   jresult = (void *)result;
2757   return jresult;
2758 }
2759
2760
2761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2762   intp *arg1 = (intp *) 0 ;
2763
2764   arg1 = (intp *)jarg1;
2765   {
2766     try {
2767       delete_intp(arg1);
2768     } catch (std::out_of_range& e) {
2769       {
2770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2771       };
2772     } catch (std::exception& e) {
2773       {
2774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2775       };
2776     } catch (Dali::DaliException e) {
2777       {
2778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2779       };
2780     } catch (...) {
2781       {
2782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2783       };
2784     }
2785   }
2786
2787 }
2788
2789
2790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2791   intp *arg1 = (intp *) 0 ;
2792   int arg2 ;
2793
2794   arg1 = (intp *)jarg1;
2795   arg2 = (int)jarg2;
2796   {
2797     try {
2798       intp_assign(arg1,arg2);
2799     } catch (std::out_of_range& e) {
2800       {
2801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2802       };
2803     } catch (std::exception& e) {
2804       {
2805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2806       };
2807     } catch (Dali::DaliException e) {
2808       {
2809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2810       };
2811     } catch (...) {
2812       {
2813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2814       };
2815     }
2816   }
2817
2818 }
2819
2820
2821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2822   int jresult ;
2823   intp *arg1 = (intp *) 0 ;
2824   int result;
2825
2826   arg1 = (intp *)jarg1;
2827   {
2828     try {
2829       result = (int)intp_value(arg1);
2830     } catch (std::out_of_range& e) {
2831       {
2832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2833       };
2834     } catch (std::exception& e) {
2835       {
2836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2837       };
2838     } catch (Dali::DaliException e) {
2839       {
2840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2841       };
2842     } catch (...) {
2843       {
2844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2845       };
2846     }
2847   }
2848
2849   jresult = result;
2850   return jresult;
2851 }
2852
2853
2854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2855   void * jresult ;
2856   intp *arg1 = (intp *) 0 ;
2857   int *result = 0 ;
2858
2859   arg1 = (intp *)jarg1;
2860   {
2861     try {
2862       result = (int *)intp_cast(arg1);
2863     } catch (std::out_of_range& e) {
2864       {
2865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2866       };
2867     } catch (std::exception& e) {
2868       {
2869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2870       };
2871     } catch (Dali::DaliException e) {
2872       {
2873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2874       };
2875     } catch (...) {
2876       {
2877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2878       };
2879     }
2880   }
2881
2882   jresult = (void *)result;
2883   return jresult;
2884 }
2885
2886
2887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2888   void * jresult ;
2889   int *arg1 = (int *) 0 ;
2890   intp *result = 0 ;
2891
2892   arg1 = (int *)jarg1;
2893   {
2894     try {
2895       result = (intp *)intp_frompointer(arg1);
2896     } catch (std::out_of_range& e) {
2897       {
2898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2899       };
2900     } catch (std::exception& e) {
2901       {
2902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2903       };
2904     } catch (Dali::DaliException e) {
2905       {
2906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2907       };
2908     } catch (...) {
2909       {
2910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2911       };
2912     }
2913   }
2914
2915   jresult = (void *)result;
2916   return jresult;
2917 }
2918
2919
2920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2921   void * jresult ;
2922   doublep *result = 0 ;
2923
2924   {
2925     try {
2926       result = (doublep *)new_doublep();
2927     } catch (std::out_of_range& e) {
2928       {
2929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2930       };
2931     } catch (std::exception& e) {
2932       {
2933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2934       };
2935     } catch (Dali::DaliException e) {
2936       {
2937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2938       };
2939     } catch (...) {
2940       {
2941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2942       };
2943     }
2944   }
2945
2946   jresult = (void *)result;
2947   return jresult;
2948 }
2949
2950
2951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2952   doublep *arg1 = (doublep *) 0 ;
2953
2954   arg1 = (doublep *)jarg1;
2955   {
2956     try {
2957       delete_doublep(arg1);
2958     } catch (std::out_of_range& e) {
2959       {
2960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2961       };
2962     } catch (std::exception& e) {
2963       {
2964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2965       };
2966     } catch (Dali::DaliException e) {
2967       {
2968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2969       };
2970     } catch (...) {
2971       {
2972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2973       };
2974     }
2975   }
2976
2977 }
2978
2979
2980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2981   doublep *arg1 = (doublep *) 0 ;
2982   double arg2 ;
2983
2984   arg1 = (doublep *)jarg1;
2985   arg2 = (double)jarg2;
2986   {
2987     try {
2988       doublep_assign(arg1,arg2);
2989     } catch (std::out_of_range& e) {
2990       {
2991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2992       };
2993     } catch (std::exception& e) {
2994       {
2995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2996       };
2997     } catch (Dali::DaliException e) {
2998       {
2999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3000       };
3001     } catch (...) {
3002       {
3003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3004       };
3005     }
3006   }
3007
3008 }
3009
3010
3011 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3012   double jresult ;
3013   doublep *arg1 = (doublep *) 0 ;
3014   double result;
3015
3016   arg1 = (doublep *)jarg1;
3017   {
3018     try {
3019       result = (double)doublep_value(arg1);
3020     } catch (std::out_of_range& e) {
3021       {
3022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3023       };
3024     } catch (std::exception& e) {
3025       {
3026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3027       };
3028     } catch (Dali::DaliException e) {
3029       {
3030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3031       };
3032     } catch (...) {
3033       {
3034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3035       };
3036     }
3037   }
3038
3039   jresult = result;
3040   return jresult;
3041 }
3042
3043
3044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3045   void * jresult ;
3046   doublep *arg1 = (doublep *) 0 ;
3047   double *result = 0 ;
3048
3049   arg1 = (doublep *)jarg1;
3050   {
3051     try {
3052       result = (double *)doublep_cast(arg1);
3053     } catch (std::out_of_range& e) {
3054       {
3055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3056       };
3057     } catch (std::exception& e) {
3058       {
3059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3060       };
3061     } catch (Dali::DaliException e) {
3062       {
3063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3064       };
3065     } catch (...) {
3066       {
3067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3068       };
3069     }
3070   }
3071
3072   jresult = (void *)result;
3073   return jresult;
3074 }
3075
3076
3077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3078   void * jresult ;
3079   double *arg1 = (double *) 0 ;
3080   doublep *result = 0 ;
3081
3082   arg1 = (double *)jarg1;
3083   {
3084     try {
3085       result = (doublep *)doublep_frompointer(arg1);
3086     } catch (std::out_of_range& e) {
3087       {
3088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3089       };
3090     } catch (std::exception& e) {
3091       {
3092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3093       };
3094     } catch (Dali::DaliException e) {
3095       {
3096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3097       };
3098     } catch (...) {
3099       {
3100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3101       };
3102     }
3103   }
3104
3105   jresult = (void *)result;
3106   return jresult;
3107 }
3108
3109
3110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3111   void * jresult ;
3112   uintp *result = 0 ;
3113
3114   {
3115     try {
3116       result = (uintp *)new_uintp();
3117     } catch (std::out_of_range& e) {
3118       {
3119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3120       };
3121     } catch (std::exception& e) {
3122       {
3123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3124       };
3125     } catch (Dali::DaliException e) {
3126       {
3127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3128       };
3129     } catch (...) {
3130       {
3131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3132       };
3133     }
3134   }
3135
3136   jresult = (void *)result;
3137   return jresult;
3138 }
3139
3140
3141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3142   uintp *arg1 = (uintp *) 0 ;
3143
3144   arg1 = (uintp *)jarg1;
3145   {
3146     try {
3147       delete_uintp(arg1);
3148     } catch (std::out_of_range& e) {
3149       {
3150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3151       };
3152     } catch (std::exception& e) {
3153       {
3154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3155       };
3156     } catch (Dali::DaliException e) {
3157       {
3158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3159       };
3160     } catch (...) {
3161       {
3162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3163       };
3164     }
3165   }
3166
3167 }
3168
3169
3170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3171   uintp *arg1 = (uintp *) 0 ;
3172   unsigned int arg2 ;
3173
3174   arg1 = (uintp *)jarg1;
3175   arg2 = (unsigned int)jarg2;
3176   {
3177     try {
3178       uintp_assign(arg1,arg2);
3179     } catch (std::out_of_range& e) {
3180       {
3181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3182       };
3183     } catch (std::exception& e) {
3184       {
3185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3186       };
3187     } catch (Dali::DaliException e) {
3188       {
3189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3190       };
3191     } catch (...) {
3192       {
3193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3194       };
3195     }
3196   }
3197
3198 }
3199
3200
3201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3202   unsigned int jresult ;
3203   uintp *arg1 = (uintp *) 0 ;
3204   unsigned int result;
3205
3206   arg1 = (uintp *)jarg1;
3207   {
3208     try {
3209       result = (unsigned int)uintp_value(arg1);
3210     } catch (std::out_of_range& e) {
3211       {
3212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3213       };
3214     } catch (std::exception& e) {
3215       {
3216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3217       };
3218     } catch (Dali::DaliException e) {
3219       {
3220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3221       };
3222     } catch (...) {
3223       {
3224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3225       };
3226     }
3227   }
3228
3229   jresult = result;
3230   return jresult;
3231 }
3232
3233
3234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3235   void * jresult ;
3236   uintp *arg1 = (uintp *) 0 ;
3237   unsigned int *result = 0 ;
3238
3239   arg1 = (uintp *)jarg1;
3240   {
3241     try {
3242       result = (unsigned int *)uintp_cast(arg1);
3243     } catch (std::out_of_range& e) {
3244       {
3245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3246       };
3247     } catch (std::exception& e) {
3248       {
3249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3250       };
3251     } catch (Dali::DaliException e) {
3252       {
3253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3254       };
3255     } catch (...) {
3256       {
3257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3258       };
3259     }
3260   }
3261
3262   jresult = (void *)result;
3263   return jresult;
3264 }
3265
3266
3267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3268   void * jresult ;
3269   unsigned int *arg1 = (unsigned int *) 0 ;
3270   uintp *result = 0 ;
3271
3272   arg1 = (unsigned int *)jarg1;
3273   {
3274     try {
3275       result = (uintp *)uintp_frompointer(arg1);
3276     } catch (std::out_of_range& e) {
3277       {
3278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3279       };
3280     } catch (std::exception& e) {
3281       {
3282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3283       };
3284     } catch (Dali::DaliException e) {
3285       {
3286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3287       };
3288     } catch (...) {
3289       {
3290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3291       };
3292     }
3293   }
3294
3295   jresult = (void *)result;
3296   return jresult;
3297 }
3298
3299
3300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3301   void * jresult ;
3302   ushortp *result = 0 ;
3303
3304   {
3305     try {
3306       result = (ushortp *)new_ushortp();
3307     } catch (std::out_of_range& e) {
3308       {
3309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3310       };
3311     } catch (std::exception& e) {
3312       {
3313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3314       };
3315     } catch (Dali::DaliException e) {
3316       {
3317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3318       };
3319     } catch (...) {
3320       {
3321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3322       };
3323     }
3324   }
3325
3326   jresult = (void *)result;
3327   return jresult;
3328 }
3329
3330
3331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3332   ushortp *arg1 = (ushortp *) 0 ;
3333
3334   arg1 = (ushortp *)jarg1;
3335   {
3336     try {
3337       delete_ushortp(arg1);
3338     } catch (std::out_of_range& e) {
3339       {
3340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3341       };
3342     } catch (std::exception& e) {
3343       {
3344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3345       };
3346     } catch (Dali::DaliException e) {
3347       {
3348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3349       };
3350     } catch (...) {
3351       {
3352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3353       };
3354     }
3355   }
3356
3357 }
3358
3359
3360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3361   ushortp *arg1 = (ushortp *) 0 ;
3362   unsigned short arg2 ;
3363
3364   arg1 = (ushortp *)jarg1;
3365   arg2 = (unsigned short)jarg2;
3366   {
3367     try {
3368       ushortp_assign(arg1,arg2);
3369     } catch (std::out_of_range& e) {
3370       {
3371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3372       };
3373     } catch (std::exception& e) {
3374       {
3375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3376       };
3377     } catch (Dali::DaliException e) {
3378       {
3379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3380       };
3381     } catch (...) {
3382       {
3383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3384       };
3385     }
3386   }
3387
3388 }
3389
3390
3391 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3392   unsigned short jresult ;
3393   ushortp *arg1 = (ushortp *) 0 ;
3394   unsigned short result;
3395
3396   arg1 = (ushortp *)jarg1;
3397   {
3398     try {
3399       result = (unsigned short)ushortp_value(arg1);
3400     } catch (std::out_of_range& e) {
3401       {
3402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3403       };
3404     } catch (std::exception& e) {
3405       {
3406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3407       };
3408     } catch (Dali::DaliException e) {
3409       {
3410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3411       };
3412     } catch (...) {
3413       {
3414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3415       };
3416     }
3417   }
3418
3419   jresult = result;
3420   return jresult;
3421 }
3422
3423
3424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3425   void * jresult ;
3426   ushortp *arg1 = (ushortp *) 0 ;
3427   unsigned short *result = 0 ;
3428
3429   arg1 = (ushortp *)jarg1;
3430   {
3431     try {
3432       result = (unsigned short *)ushortp_cast(arg1);
3433     } catch (std::out_of_range& e) {
3434       {
3435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3436       };
3437     } catch (std::exception& e) {
3438       {
3439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3440       };
3441     } catch (Dali::DaliException e) {
3442       {
3443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3444       };
3445     } catch (...) {
3446       {
3447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3448       };
3449     }
3450   }
3451
3452   jresult = (void *)result;
3453   return jresult;
3454 }
3455
3456
3457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3458   void * jresult ;
3459   unsigned short *arg1 = (unsigned short *) 0 ;
3460   ushortp *result = 0 ;
3461
3462   arg1 = (unsigned short *)jarg1;
3463   {
3464     try {
3465       result = (ushortp *)ushortp_frompointer(arg1);
3466     } catch (std::out_of_range& e) {
3467       {
3468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3469       };
3470     } catch (std::exception& e) {
3471       {
3472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3473       };
3474     } catch (Dali::DaliException e) {
3475       {
3476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3477       };
3478     } catch (...) {
3479       {
3480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3481       };
3482     }
3483   }
3484
3485   jresult = (void *)result;
3486   return jresult;
3487 }
3488
3489
3490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3491   unsigned int jresult ;
3492   int arg1 ;
3493   unsigned int result;
3494
3495   arg1 = (int)jarg1;
3496   {
3497     try {
3498       result = (unsigned int)int_to_uint(arg1);
3499     } catch (std::out_of_range& e) {
3500       {
3501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3502       };
3503     } catch (std::exception& e) {
3504       {
3505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3506       };
3507     } catch (Dali::DaliException e) {
3508       {
3509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3510       };
3511     } catch (...) {
3512       {
3513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3514       };
3515     }
3516   }
3517
3518   jresult = result;
3519   return jresult;
3520 }
3521
3522
3523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3524   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3525
3526   arg1 = (Dali::RefObject *)jarg1;
3527   {
3528     try {
3529       (arg1)->Reference();
3530     } catch (std::out_of_range& e) {
3531       {
3532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3533       };
3534     } catch (std::exception& e) {
3535       {
3536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3537       };
3538     } catch (Dali::DaliException e) {
3539       {
3540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3541       };
3542     } catch (...) {
3543       {
3544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3545       };
3546     }
3547   }
3548
3549 }
3550
3551
3552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3553   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3554
3555   arg1 = (Dali::RefObject *)jarg1;
3556   {
3557     try {
3558       (arg1)->Unreference();
3559     } catch (std::out_of_range& e) {
3560       {
3561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3562       };
3563     } catch (std::exception& e) {
3564       {
3565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3566       };
3567     } catch (Dali::DaliException e) {
3568       {
3569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3570       };
3571     } catch (...) {
3572       {
3573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3574       };
3575     }
3576   }
3577
3578 }
3579
3580
3581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3582   int jresult ;
3583   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3584   int result;
3585
3586   arg1 = (Dali::RefObject *)jarg1;
3587   {
3588     try {
3589       result = (int)(arg1)->ReferenceCount();
3590     } catch (std::out_of_range& e) {
3591       {
3592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3593       };
3594     } catch (std::exception& e) {
3595       {
3596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3597       };
3598     } catch (Dali::DaliException e) {
3599       {
3600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3601       };
3602     } catch (...) {
3603       {
3604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3605       };
3606     }
3607   }
3608
3609   jresult = result;
3610   return jresult;
3611 }
3612
3613
3614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3615   void * jresult ;
3616   Dali::Any *result = 0 ;
3617
3618   {
3619     try {
3620       result = (Dali::Any *)new Dali::Any();
3621     } catch (std::out_of_range& e) {
3622       {
3623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3624       };
3625     } catch (std::exception& e) {
3626       {
3627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3628       };
3629     } catch (Dali::DaliException e) {
3630       {
3631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3632       };
3633     } catch (...) {
3634       {
3635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3636       };
3637     }
3638   }
3639
3640   jresult = (void *)result;
3641   return jresult;
3642 }
3643
3644
3645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3646   Dali::Any *arg1 = (Dali::Any *) 0 ;
3647
3648   arg1 = (Dali::Any *)jarg1;
3649   {
3650     try {
3651       delete arg1;
3652     } catch (std::out_of_range& e) {
3653       {
3654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3655       };
3656     } catch (std::exception& e) {
3657       {
3658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3659       };
3660     } catch (Dali::DaliException e) {
3661       {
3662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3663       };
3664     } catch (...) {
3665       {
3666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3667       };
3668     }
3669   }
3670
3671 }
3672
3673
3674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3675   char *arg1 = (char *) 0 ;
3676
3677   arg1 = (char *)jarg1;
3678   {
3679     try {
3680       Dali::Any::AssertAlways((char const *)arg1);
3681     } catch (std::out_of_range& e) {
3682       {
3683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3684       };
3685     } catch (std::exception& e) {
3686       {
3687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3688       };
3689     } catch (Dali::DaliException e) {
3690       {
3691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3692       };
3693     } catch (...) {
3694       {
3695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3696       };
3697     }
3698   }
3699
3700 }
3701
3702
3703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3704   void * jresult ;
3705   Dali::Any *arg1 = 0 ;
3706   Dali::Any *result = 0 ;
3707
3708   arg1 = (Dali::Any *)jarg1;
3709   if (!arg1) {
3710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3711     return 0;
3712   }
3713   {
3714     try {
3715       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3716     } catch (std::out_of_range& e) {
3717       {
3718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3719       };
3720     } catch (std::exception& e) {
3721       {
3722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3723       };
3724     } catch (Dali::DaliException e) {
3725       {
3726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3727       };
3728     } catch (...) {
3729       {
3730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3731       };
3732     }
3733   }
3734
3735   jresult = (void *)result;
3736   return jresult;
3737 }
3738
3739
3740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3741   void * jresult ;
3742   Dali::Any *arg1 = (Dali::Any *) 0 ;
3743   Dali::Any *arg2 = 0 ;
3744   Dali::Any *result = 0 ;
3745
3746   arg1 = (Dali::Any *)jarg1;
3747   arg2 = (Dali::Any *)jarg2;
3748   if (!arg2) {
3749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3750     return 0;
3751   }
3752   {
3753     try {
3754       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3755     } catch (std::out_of_range& e) {
3756       {
3757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3758       };
3759     } catch (std::exception& e) {
3760       {
3761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3762       };
3763     } catch (Dali::DaliException e) {
3764       {
3765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3766       };
3767     } catch (...) {
3768       {
3769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3770       };
3771     }
3772   }
3773
3774   jresult = (void *)result;
3775   return jresult;
3776 }
3777
3778
3779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3780   void * jresult ;
3781   Dali::Any *arg1 = (Dali::Any *) 0 ;
3782   std::type_info *result = 0 ;
3783
3784   arg1 = (Dali::Any *)jarg1;
3785   {
3786     try {
3787       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3788     } catch (std::out_of_range& e) {
3789       {
3790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3791       };
3792     } catch (std::exception& e) {
3793       {
3794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3795       };
3796     } catch (Dali::DaliException e) {
3797       {
3798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3799       };
3800     } catch (...) {
3801       {
3802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3803       };
3804     }
3805   }
3806
3807   jresult = (void *)result;
3808   return jresult;
3809 }
3810
3811
3812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3813   unsigned int jresult ;
3814   Dali::Any *arg1 = (Dali::Any *) 0 ;
3815   bool result;
3816
3817   arg1 = (Dali::Any *)jarg1;
3818   {
3819     try {
3820       result = (bool)((Dali::Any const *)arg1)->Empty();
3821     } catch (std::out_of_range& e) {
3822       {
3823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3824       };
3825     } catch (std::exception& e) {
3826       {
3827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3828       };
3829     } catch (Dali::DaliException e) {
3830       {
3831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3832       };
3833     } catch (...) {
3834       {
3835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3836       };
3837     }
3838   }
3839
3840   jresult = result;
3841   return jresult;
3842 }
3843
3844
3845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3846   void * jresult ;
3847   std::type_info *arg1 = 0 ;
3848   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3849   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3850   Dali::Any::AnyContainerBase *result = 0 ;
3851
3852   arg1 = (std::type_info *)jarg1;
3853   if (!arg1) {
3854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3855     return 0;
3856   }
3857   arg2 = (Dali::Any::CloneFunc)jarg2;
3858   arg3 = (Dali::Any::DeleteFunc)jarg3;
3859   {
3860     try {
3861       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3862     } catch (std::out_of_range& e) {
3863       {
3864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3865       };
3866     } catch (std::exception& e) {
3867       {
3868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3869       };
3870     } catch (Dali::DaliException e) {
3871       {
3872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3873       };
3874     } catch (...) {
3875       {
3876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3877       };
3878     }
3879   }
3880
3881   jresult = (void *)result;
3882   return jresult;
3883 }
3884
3885
3886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3887   void * jresult ;
3888   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3889   std::type_info *result = 0 ;
3890
3891   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3892   {
3893     try {
3894       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3895     } catch (std::out_of_range& e) {
3896       {
3897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3898       };
3899     } catch (std::exception& e) {
3900       {
3901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3902       };
3903     } catch (Dali::DaliException e) {
3904       {
3905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3906       };
3907     } catch (...) {
3908       {
3909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3910       };
3911     }
3912   }
3913
3914   jresult = (void *)result;
3915   return jresult;
3916 }
3917
3918
3919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3920   void * jresult ;
3921   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3922   ::std::type_info *result = 0 ;
3923
3924   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3925   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3926   jresult = (void *)result;
3927   return jresult;
3928 }
3929
3930
3931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3932   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3933   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3934
3935   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3936   arg2 = (Dali::Any::CloneFunc)jarg2;
3937   if (arg1) (arg1)->mCloneFunc = arg2;
3938 }
3939
3940
3941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3942   void * jresult ;
3943   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3944   Dali::Any::CloneFunc result;
3945
3946   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3947   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3948   jresult = (void *)result;
3949   return jresult;
3950 }
3951
3952
3953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3954   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3955   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3956
3957   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3958   arg2 = (Dali::Any::DeleteFunc)jarg2;
3959   if (arg1) (arg1)->mDeleteFunc = arg2;
3960 }
3961
3962
3963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3964   void * jresult ;
3965   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3966   Dali::Any::DeleteFunc result;
3967
3968   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3969   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3970   jresult = (void *)result;
3971   return jresult;
3972 }
3973
3974
3975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3976   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3977
3978   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3979   {
3980     try {
3981       delete arg1;
3982     } catch (std::out_of_range& e) {
3983       {
3984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3985       };
3986     } catch (std::exception& e) {
3987       {
3988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3989       };
3990     } catch (Dali::DaliException e) {
3991       {
3992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3993       };
3994     } catch (...) {
3995       {
3996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3997       };
3998     }
3999   }
4000
4001 }
4002
4003
4004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4005   Dali::Any *arg1 = (Dali::Any *) 0 ;
4006   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4007
4008   arg1 = (Dali::Any *)jarg1;
4009   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4010   if (arg1) (arg1)->mContainer = arg2;
4011 }
4012
4013
4014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4015   void * jresult ;
4016   Dali::Any *arg1 = (Dali::Any *) 0 ;
4017   Dali::Any::AnyContainerBase *result = 0 ;
4018
4019   arg1 = (Dali::Any *)jarg1;
4020   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4021   jresult = (void *)result;
4022   return jresult;
4023 }
4024
4025
4026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4027   char *arg1 = (char *) 0 ;
4028   char *arg2 = (char *) 0 ;
4029
4030   arg1 = (char *)jarg1;
4031   arg2 = (char *)jarg2;
4032   {
4033     try {
4034       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4035     } catch (std::out_of_range& e) {
4036       {
4037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4038       };
4039     } catch (std::exception& e) {
4040       {
4041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4042       };
4043     } catch (Dali::DaliException e) {
4044       {
4045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4046       };
4047     } catch (...) {
4048       {
4049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4050       };
4051     }
4052   }
4053
4054 }
4055
4056
4057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4058   void * jresult ;
4059   char *arg1 = (char *) 0 ;
4060   char *arg2 = (char *) 0 ;
4061   Dali::DaliException *result = 0 ;
4062
4063   arg1 = (char *)jarg1;
4064   arg2 = (char *)jarg2;
4065   {
4066     try {
4067       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4068     } catch (std::out_of_range& e) {
4069       {
4070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4071       };
4072     } catch (std::exception& e) {
4073       {
4074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4075       };
4076     } catch (Dali::DaliException e) {
4077       {
4078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4079       };
4080     } catch (...) {
4081       {
4082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4083       };
4084     }
4085   }
4086
4087   jresult = (void *)result;
4088   return jresult;
4089 }
4090
4091
4092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4093   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4094   std::string arg2 = std::string(jarg2);
4095
4096   arg1 = (Dali::DaliException *)jarg1;
4097   {
4098     if (!arg2.empty()) {
4099       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4100     } else {
4101       arg1->location = 0;
4102     }
4103   }
4104 }
4105
4106 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4107   char * jresult ;
4108   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4109   char *result = 0 ;
4110
4111   arg1 = (Dali::DaliException *)jarg1;
4112   result = (char *) ((arg1)->location);
4113   jresult = SWIG_csharp_string_callback((const char *)result);
4114   return jresult;
4115 }
4116
4117
4118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4119   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4120   std::string arg2 = std::string(jarg2);
4121
4122   arg1 = (Dali::DaliException *)jarg1;
4123   {
4124     if (!arg2.empty()) {
4125       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4126     } else {
4127       arg1->condition = 0;
4128     }
4129   }
4130 }
4131
4132
4133 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4134   char * jresult ;
4135   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4136   char *result = 0 ;
4137
4138   arg1 = (Dali::DaliException *)jarg1;
4139   result = (char *) ((arg1)->condition);
4140   jresult = SWIG_csharp_string_callback((const char *)result);
4141   return jresult;
4142 }
4143
4144
4145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4146   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4147
4148   arg1 = (Dali::DaliException *)jarg1;
4149   {
4150     try {
4151       delete arg1;
4152     } catch (std::out_of_range& e) {
4153       {
4154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4155       };
4156     } catch (std::exception& e) {
4157       {
4158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4159       };
4160     } catch (Dali::DaliException e) {
4161       {
4162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4163       };
4164     } catch (...) {
4165       {
4166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4167       };
4168     }
4169   }
4170
4171 }
4172
4173
4174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4175   void * jresult ;
4176   Dali::Vector2 *result = 0 ;
4177
4178   {
4179     try {
4180       result = (Dali::Vector2 *)new Dali::Vector2();
4181     } catch (std::out_of_range& e) {
4182       {
4183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4184       };
4185     } catch (std::exception& e) {
4186       {
4187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4188       };
4189     } catch (Dali::DaliException e) {
4190       {
4191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4192       };
4193     } catch (...) {
4194       {
4195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4196       };
4197     }
4198   }
4199
4200   jresult = (void *)result;
4201   return jresult;
4202 }
4203
4204
4205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4206   void * jresult ;
4207   float arg1 ;
4208   float arg2 ;
4209   Dali::Vector2 *result = 0 ;
4210
4211   arg1 = (float)jarg1;
4212   arg2 = (float)jarg2;
4213   {
4214     try {
4215       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4216     } catch (std::out_of_range& e) {
4217       {
4218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4219       };
4220     } catch (std::exception& e) {
4221       {
4222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4223       };
4224     } catch (Dali::DaliException e) {
4225       {
4226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4227       };
4228     } catch (...) {
4229       {
4230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4231       };
4232     }
4233   }
4234
4235   jresult = (void *)result;
4236   return jresult;
4237 }
4238
4239
4240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4241   void * jresult ;
4242   float *arg1 = (float *) 0 ;
4243   Dali::Vector2 *result = 0 ;
4244
4245   arg1 = jarg1;
4246   {
4247     try {
4248       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4249     } catch (std::out_of_range& e) {
4250       {
4251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4252       };
4253     } catch (std::exception& e) {
4254       {
4255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4256       };
4257     } catch (Dali::DaliException e) {
4258       {
4259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4260       };
4261     } catch (...) {
4262       {
4263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4264       };
4265     }
4266   }
4267
4268   jresult = (void *)result;
4269
4270
4271   return jresult;
4272 }
4273
4274
4275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4276   void * jresult ;
4277   Dali::Vector3 *arg1 = 0 ;
4278   Dali::Vector2 *result = 0 ;
4279
4280   arg1 = (Dali::Vector3 *)jarg1;
4281   if (!arg1) {
4282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4283     return 0;
4284   }
4285   {
4286     try {
4287       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4288     } catch (std::out_of_range& e) {
4289       {
4290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4291       };
4292     } catch (std::exception& e) {
4293       {
4294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4295       };
4296     } catch (Dali::DaliException e) {
4297       {
4298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4299       };
4300     } catch (...) {
4301       {
4302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4303       };
4304     }
4305   }
4306
4307   jresult = (void *)result;
4308   return jresult;
4309 }
4310
4311
4312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4313   void * jresult ;
4314   Dali::Vector4 *arg1 = 0 ;
4315   Dali::Vector2 *result = 0 ;
4316
4317   arg1 = (Dali::Vector4 *)jarg1;
4318   if (!arg1) {
4319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4320     return 0;
4321   }
4322   {
4323     try {
4324       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4325     } catch (std::out_of_range& e) {
4326       {
4327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4328       };
4329     } catch (std::exception& e) {
4330       {
4331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4332       };
4333     } catch (Dali::DaliException e) {
4334       {
4335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4336       };
4337     } catch (...) {
4338       {
4339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4340       };
4341     }
4342   }
4343
4344   jresult = (void *)result;
4345   return jresult;
4346 }
4347
4348
4349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4350   void * jresult ;
4351   Dali::Vector2 *result = 0 ;
4352
4353   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4354   jresult = (void *)result;
4355   return jresult;
4356 }
4357
4358
4359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4360   void * jresult ;
4361   Dali::Vector2 *result = 0 ;
4362
4363   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4364   jresult = (void *)result;
4365   return jresult;
4366 }
4367
4368
4369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4370   void * jresult ;
4371   Dali::Vector2 *result = 0 ;
4372
4373   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4374   jresult = (void *)result;
4375   return jresult;
4376 }
4377
4378
4379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4380   void * jresult ;
4381   Dali::Vector2 *result = 0 ;
4382
4383   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4384   jresult = (void *)result;
4385   return jresult;
4386 }
4387
4388
4389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4390   void * jresult ;
4391   Dali::Vector2 *result = 0 ;
4392
4393   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4394   jresult = (void *)result;
4395   return jresult;
4396 }
4397
4398
4399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4400   void * jresult ;
4401   Dali::Vector2 *result = 0 ;
4402
4403   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4404   jresult = (void *)result;
4405   return jresult;
4406 }
4407
4408
4409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4410   void * jresult ;
4411   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4412   float *arg2 = (float *) 0 ;
4413   Dali::Vector2 *result = 0 ;
4414
4415   arg1 = (Dali::Vector2 *)jarg1;
4416   arg2 = jarg2;
4417   {
4418     try {
4419       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4420     } catch (std::out_of_range& e) {
4421       {
4422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4423       };
4424     } catch (std::exception& e) {
4425       {
4426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4427       };
4428     } catch (Dali::DaliException e) {
4429       {
4430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4431       };
4432     } catch (...) {
4433       {
4434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4435       };
4436     }
4437   }
4438
4439   jresult = (void *)result;
4440
4441
4442   return jresult;
4443 }
4444
4445
4446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4447   void * jresult ;
4448   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4449   Dali::Vector3 *arg2 = 0 ;
4450   Dali::Vector2 *result = 0 ;
4451
4452   arg1 = (Dali::Vector2 *)jarg1;
4453   arg2 = (Dali::Vector3 *)jarg2;
4454   if (!arg2) {
4455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4456     return 0;
4457   }
4458   {
4459     try {
4460       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4461     } catch (std::out_of_range& e) {
4462       {
4463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4464       };
4465     } catch (std::exception& e) {
4466       {
4467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4468       };
4469     } catch (Dali::DaliException e) {
4470       {
4471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4472       };
4473     } catch (...) {
4474       {
4475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4476       };
4477     }
4478   }
4479
4480   jresult = (void *)result;
4481   return jresult;
4482 }
4483
4484
4485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4486   void * jresult ;
4487   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4488   Dali::Vector4 *arg2 = 0 ;
4489   Dali::Vector2 *result = 0 ;
4490
4491   arg1 = (Dali::Vector2 *)jarg1;
4492   arg2 = (Dali::Vector4 *)jarg2;
4493   if (!arg2) {
4494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4495     return 0;
4496   }
4497   {
4498     try {
4499       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4500     } catch (std::out_of_range& e) {
4501       {
4502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4503       };
4504     } catch (std::exception& e) {
4505       {
4506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4507       };
4508     } catch (Dali::DaliException e) {
4509       {
4510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4511       };
4512     } catch (...) {
4513       {
4514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4515       };
4516     }
4517   }
4518
4519   jresult = (void *)result;
4520   return jresult;
4521 }
4522
4523
4524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4525   void * jresult ;
4526   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4527   Dali::Vector2 *arg2 = 0 ;
4528   Dali::Vector2 result;
4529
4530   arg1 = (Dali::Vector2 *)jarg1;
4531   arg2 = (Dali::Vector2 *)jarg2;
4532   if (!arg2) {
4533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4534     return 0;
4535   }
4536   {
4537     try {
4538       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4539     } catch (std::out_of_range& e) {
4540       {
4541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4542       };
4543     } catch (std::exception& e) {
4544       {
4545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4546       };
4547     } catch (Dali::DaliException e) {
4548       {
4549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4550       };
4551     } catch (...) {
4552       {
4553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4554       };
4555     }
4556   }
4557
4558   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4559   return jresult;
4560 }
4561
4562
4563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4564   void * jresult ;
4565   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4566   Dali::Vector2 *arg2 = 0 ;
4567   Dali::Vector2 *result = 0 ;
4568
4569   arg1 = (Dali::Vector2 *)jarg1;
4570   arg2 = (Dali::Vector2 *)jarg2;
4571   if (!arg2) {
4572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4573     return 0;
4574   }
4575   {
4576     try {
4577       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4578     } catch (std::out_of_range& e) {
4579       {
4580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4581       };
4582     } catch (std::exception& e) {
4583       {
4584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4585       };
4586     } catch (Dali::DaliException e) {
4587       {
4588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4589       };
4590     } catch (...) {
4591       {
4592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4593       };
4594     }
4595   }
4596
4597   jresult = (void *)result;
4598   return jresult;
4599 }
4600
4601
4602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4603   void * jresult ;
4604   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4605   Dali::Vector2 *arg2 = 0 ;
4606   Dali::Vector2 result;
4607
4608   arg1 = (Dali::Vector2 *)jarg1;
4609   arg2 = (Dali::Vector2 *)jarg2;
4610   if (!arg2) {
4611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4612     return 0;
4613   }
4614   {
4615     try {
4616       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4617     } catch (std::out_of_range& e) {
4618       {
4619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4620       };
4621     } catch (std::exception& e) {
4622       {
4623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4624       };
4625     } catch (Dali::DaliException e) {
4626       {
4627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4628       };
4629     } catch (...) {
4630       {
4631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4632       };
4633     }
4634   }
4635
4636   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4637   return jresult;
4638 }
4639
4640
4641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4642   void * jresult ;
4643   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4644   Dali::Vector2 *arg2 = 0 ;
4645   Dali::Vector2 *result = 0 ;
4646
4647   arg1 = (Dali::Vector2 *)jarg1;
4648   arg2 = (Dali::Vector2 *)jarg2;
4649   if (!arg2) {
4650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4651     return 0;
4652   }
4653   {
4654     try {
4655       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4656     } catch (std::out_of_range& e) {
4657       {
4658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4659       };
4660     } catch (std::exception& e) {
4661       {
4662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4663       };
4664     } catch (Dali::DaliException e) {
4665       {
4666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4667       };
4668     } catch (...) {
4669       {
4670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4671       };
4672     }
4673   }
4674
4675   jresult = (void *)result;
4676   return jresult;
4677 }
4678
4679
4680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4681   void * jresult ;
4682   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4683   Dali::Vector2 *arg2 = 0 ;
4684   Dali::Vector2 result;
4685
4686   arg1 = (Dali::Vector2 *)jarg1;
4687   arg2 = (Dali::Vector2 *)jarg2;
4688   if (!arg2) {
4689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4690     return 0;
4691   }
4692   {
4693     try {
4694       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4695     } catch (std::out_of_range& e) {
4696       {
4697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4698       };
4699     } catch (std::exception& e) {
4700       {
4701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4702       };
4703     } catch (Dali::DaliException e) {
4704       {
4705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4706       };
4707     } catch (...) {
4708       {
4709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4710       };
4711     }
4712   }
4713
4714   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4715   return jresult;
4716 }
4717
4718
4719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4720   void * jresult ;
4721   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4722   float arg2 ;
4723   Dali::Vector2 result;
4724
4725   arg1 = (Dali::Vector2 *)jarg1;
4726   arg2 = (float)jarg2;
4727   {
4728     try {
4729       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4730     } catch (std::out_of_range& e) {
4731       {
4732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4733       };
4734     } catch (std::exception& e) {
4735       {
4736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4737       };
4738     } catch (Dali::DaliException e) {
4739       {
4740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4741       };
4742     } catch (...) {
4743       {
4744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4745       };
4746     }
4747   }
4748
4749   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4750   return jresult;
4751 }
4752
4753
4754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4755   void * jresult ;
4756   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4757   Dali::Vector2 *arg2 = 0 ;
4758   Dali::Vector2 *result = 0 ;
4759
4760   arg1 = (Dali::Vector2 *)jarg1;
4761   arg2 = (Dali::Vector2 *)jarg2;
4762   if (!arg2) {
4763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4764     return 0;
4765   }
4766   {
4767     try {
4768       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4769     } catch (std::out_of_range& e) {
4770       {
4771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4772       };
4773     } catch (std::exception& e) {
4774       {
4775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4776       };
4777     } catch (Dali::DaliException e) {
4778       {
4779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4780       };
4781     } catch (...) {
4782       {
4783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4784       };
4785     }
4786   }
4787
4788   jresult = (void *)result;
4789   return jresult;
4790 }
4791
4792
4793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4794   void * jresult ;
4795   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4796   float arg2 ;
4797   Dali::Vector2 *result = 0 ;
4798
4799   arg1 = (Dali::Vector2 *)jarg1;
4800   arg2 = (float)jarg2;
4801   {
4802     try {
4803       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4804     } catch (std::out_of_range& e) {
4805       {
4806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4807       };
4808     } catch (std::exception& e) {
4809       {
4810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4811       };
4812     } catch (Dali::DaliException e) {
4813       {
4814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4815       };
4816     } catch (...) {
4817       {
4818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4819       };
4820     }
4821   }
4822
4823   jresult = (void *)result;
4824   return jresult;
4825 }
4826
4827
4828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4829   void * jresult ;
4830   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4831   Dali::Vector2 *arg2 = 0 ;
4832   Dali::Vector2 result;
4833
4834   arg1 = (Dali::Vector2 *)jarg1;
4835   arg2 = (Dali::Vector2 *)jarg2;
4836   if (!arg2) {
4837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4838     return 0;
4839   }
4840   {
4841     try {
4842       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4843     } catch (std::out_of_range& e) {
4844       {
4845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4846       };
4847     } catch (std::exception& e) {
4848       {
4849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4850       };
4851     } catch (Dali::DaliException e) {
4852       {
4853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4854       };
4855     } catch (...) {
4856       {
4857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4858       };
4859     }
4860   }
4861
4862   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4863   return jresult;
4864 }
4865
4866
4867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4868   void * jresult ;
4869   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4870   float arg2 ;
4871   Dali::Vector2 result;
4872
4873   arg1 = (Dali::Vector2 *)jarg1;
4874   arg2 = (float)jarg2;
4875   {
4876     try {
4877       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4878     } catch (std::out_of_range& e) {
4879       {
4880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4881       };
4882     } catch (std::exception& e) {
4883       {
4884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4885       };
4886     } catch (Dali::DaliException e) {
4887       {
4888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4889       };
4890     } catch (...) {
4891       {
4892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4893       };
4894     }
4895   }
4896
4897   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4898   return jresult;
4899 }
4900
4901
4902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4903   void * jresult ;
4904   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4905   Dali::Vector2 *arg2 = 0 ;
4906   Dali::Vector2 *result = 0 ;
4907
4908   arg1 = (Dali::Vector2 *)jarg1;
4909   arg2 = (Dali::Vector2 *)jarg2;
4910   if (!arg2) {
4911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4912     return 0;
4913   }
4914   {
4915     try {
4916       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4917     } catch (std::out_of_range& e) {
4918       {
4919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4920       };
4921     } catch (std::exception& e) {
4922       {
4923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4924       };
4925     } catch (Dali::DaliException e) {
4926       {
4927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4928       };
4929     } catch (...) {
4930       {
4931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4932       };
4933     }
4934   }
4935
4936   jresult = (void *)result;
4937   return jresult;
4938 }
4939
4940
4941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4942   void * jresult ;
4943   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4944   float arg2 ;
4945   Dali::Vector2 *result = 0 ;
4946
4947   arg1 = (Dali::Vector2 *)jarg1;
4948   arg2 = (float)jarg2;
4949   {
4950     try {
4951       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4952     } catch (std::out_of_range& e) {
4953       {
4954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4955       };
4956     } catch (std::exception& e) {
4957       {
4958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4959       };
4960     } catch (Dali::DaliException e) {
4961       {
4962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4963       };
4964     } catch (...) {
4965       {
4966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4967       };
4968     }
4969   }
4970
4971   jresult = (void *)result;
4972   return jresult;
4973 }
4974
4975
4976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4977   void * jresult ;
4978   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4979   Dali::Vector2 result;
4980
4981   arg1 = (Dali::Vector2 *)jarg1;
4982   {
4983     try {
4984       result = ((Dali::Vector2 const *)arg1)->operator -();
4985     } catch (std::out_of_range& e) {
4986       {
4987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4988       };
4989     } catch (std::exception& e) {
4990       {
4991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4992       };
4993     } catch (Dali::DaliException e) {
4994       {
4995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4996       };
4997     } catch (...) {
4998       {
4999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5000       };
5001     }
5002   }
5003
5004   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5005   return jresult;
5006 }
5007
5008
5009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5010   unsigned int jresult ;
5011   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5012   Dali::Vector2 *arg2 = 0 ;
5013   bool result;
5014
5015   arg1 = (Dali::Vector2 *)jarg1;
5016   arg2 = (Dali::Vector2 *)jarg2;
5017   if (!arg2) {
5018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5019     return 0;
5020   }
5021   {
5022     try {
5023       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5024     } catch (std::out_of_range& e) {
5025       {
5026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5027       };
5028     } catch (std::exception& e) {
5029       {
5030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5031       };
5032     } catch (Dali::DaliException e) {
5033       {
5034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5035       };
5036     } catch (...) {
5037       {
5038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5039       };
5040     }
5041   }
5042
5043   jresult = result;
5044   return jresult;
5045 }
5046
5047
5048 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5049   unsigned int jresult ;
5050   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5051   Dali::Vector2 *arg2 = 0 ;
5052   bool result;
5053
5054   arg1 = (Dali::Vector2 *)jarg1;
5055   arg2 = (Dali::Vector2 *)jarg2;
5056   if (!arg2) {
5057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5058     return 0;
5059   }
5060   {
5061     try {
5062       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5063     } catch (std::out_of_range& e) {
5064       {
5065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5066       };
5067     } catch (std::exception& e) {
5068       {
5069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5070       };
5071     } catch (Dali::DaliException e) {
5072       {
5073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5074       };
5075     } catch (...) {
5076       {
5077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5078       };
5079     }
5080   }
5081
5082   jresult = result;
5083   return jresult;
5084 }
5085
5086
5087 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5088   float jresult ;
5089   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5090   unsigned int arg2 ;
5091   float *result = 0 ;
5092
5093   arg1 = (Dali::Vector2 *)jarg1;
5094   arg2 = (unsigned int)jarg2;
5095   {
5096     try {
5097       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5098     } catch (std::out_of_range& e) {
5099       {
5100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5101       };
5102     } catch (std::exception& e) {
5103       {
5104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5105       };
5106     } catch (Dali::DaliException e) {
5107       {
5108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5109       };
5110     } catch (...) {
5111       {
5112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5113       };
5114     }
5115   }
5116
5117   jresult = *result;
5118   return jresult;
5119 }
5120
5121
5122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5123   float jresult ;
5124   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5125   float result;
5126
5127   arg1 = (Dali::Vector2 *)jarg1;
5128   {
5129     try {
5130       result = (float)((Dali::Vector2 const *)arg1)->Length();
5131     } catch (std::out_of_range& e) {
5132       {
5133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5134       };
5135     } catch (std::exception& e) {
5136       {
5137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5138       };
5139     } catch (Dali::DaliException e) {
5140       {
5141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5142       };
5143     } catch (...) {
5144       {
5145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5146       };
5147     }
5148   }
5149
5150   jresult = result;
5151   return jresult;
5152 }
5153
5154
5155 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5156   float jresult ;
5157   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5158   float result;
5159
5160   arg1 = (Dali::Vector2 *)jarg1;
5161   {
5162     try {
5163       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5164     } catch (std::out_of_range& e) {
5165       {
5166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5167       };
5168     } catch (std::exception& e) {
5169       {
5170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5171       };
5172     } catch (Dali::DaliException e) {
5173       {
5174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5175       };
5176     } catch (...) {
5177       {
5178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5179       };
5180     }
5181   }
5182
5183   jresult = result;
5184   return jresult;
5185 }
5186
5187
5188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5189   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5190
5191   arg1 = (Dali::Vector2 *)jarg1;
5192   {
5193     try {
5194       (arg1)->Normalize();
5195     } catch (std::out_of_range& e) {
5196       {
5197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5198       };
5199     } catch (std::exception& e) {
5200       {
5201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5202       };
5203     } catch (Dali::DaliException e) {
5204       {
5205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5206       };
5207     } catch (...) {
5208       {
5209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5210       };
5211     }
5212   }
5213
5214 }
5215
5216
5217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5218   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5219   Dali::Vector2 *arg2 = 0 ;
5220   Dali::Vector2 *arg3 = 0 ;
5221
5222   arg1 = (Dali::Vector2 *)jarg1;
5223   arg2 = (Dali::Vector2 *)jarg2;
5224   if (!arg2) {
5225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5226     return ;
5227   }
5228   arg3 = (Dali::Vector2 *)jarg3;
5229   if (!arg3) {
5230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5231     return ;
5232   }
5233   {
5234     try {
5235       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5236     } catch (std::out_of_range& e) {
5237       {
5238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5239       };
5240     } catch (std::exception& e) {
5241       {
5242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5243       };
5244     } catch (Dali::DaliException e) {
5245       {
5246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5247       };
5248     } catch (...) {
5249       {
5250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5251       };
5252     }
5253   }
5254
5255 }
5256
5257
5258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5259   void * jresult ;
5260   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5261   float *result = 0 ;
5262
5263   arg1 = (Dali::Vector2 *)jarg1;
5264   {
5265     try {
5266       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5267     } catch (std::out_of_range& e) {
5268       {
5269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5270       };
5271     } catch (std::exception& e) {
5272       {
5273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5274       };
5275     } catch (Dali::DaliException e) {
5276       {
5277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5278       };
5279     } catch (...) {
5280       {
5281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5282       };
5283     }
5284   }
5285
5286   jresult = (void *)result;
5287   return jresult;
5288 }
5289
5290
5291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5292   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5293   float arg2 ;
5294
5295   arg1 = (Dali::Vector2 *)jarg1;
5296   arg2 = (float)jarg2;
5297   if (arg1) (arg1)->x = arg2;
5298 }
5299
5300
5301 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5302   float jresult ;
5303   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5304   float result;
5305
5306   arg1 = (Dali::Vector2 *)jarg1;
5307   result = (float) ((arg1)->x);
5308   jresult = result;
5309   return jresult;
5310 }
5311
5312
5313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5314   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5315   float arg2 ;
5316
5317   arg1 = (Dali::Vector2 *)jarg1;
5318   arg2 = (float)jarg2;
5319   if (arg1) (arg1)->width = arg2;
5320 }
5321
5322
5323 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5324   float jresult ;
5325   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5326   float result;
5327
5328   arg1 = (Dali::Vector2 *)jarg1;
5329   result = (float) ((arg1)->width);
5330   jresult = result;
5331   return jresult;
5332 }
5333
5334
5335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5336   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5337   float arg2 ;
5338
5339   arg1 = (Dali::Vector2 *)jarg1;
5340   arg2 = (float)jarg2;
5341   if (arg1) (arg1)->y = arg2;
5342 }
5343
5344
5345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5346   float jresult ;
5347   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5348   float result;
5349
5350   arg1 = (Dali::Vector2 *)jarg1;
5351   result = (float) ((arg1)->y);
5352   jresult = result;
5353   return jresult;
5354 }
5355
5356
5357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5358   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5359   float arg2 ;
5360
5361   arg1 = (Dali::Vector2 *)jarg1;
5362   arg2 = (float)jarg2;
5363   if (arg1) (arg1)->height = arg2;
5364 }
5365
5366
5367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5368   float jresult ;
5369   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5370   float result;
5371
5372   arg1 = (Dali::Vector2 *)jarg1;
5373   result = (float) ((arg1)->height);
5374   jresult = result;
5375   return jresult;
5376 }
5377
5378
5379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5380   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5381
5382   arg1 = (Dali::Vector2 *)jarg1;
5383   {
5384     try {
5385       delete arg1;
5386     } catch (std::out_of_range& e) {
5387       {
5388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5389       };
5390     } catch (std::exception& e) {
5391       {
5392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5393       };
5394     } catch (Dali::DaliException e) {
5395       {
5396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5397       };
5398     } catch (...) {
5399       {
5400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5401       };
5402     }
5403   }
5404
5405 }
5406
5407
5408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5409   void * jresult ;
5410   Dali::Vector2 *arg1 = 0 ;
5411   Dali::Vector2 *arg2 = 0 ;
5412   Dali::Vector2 result;
5413
5414   arg1 = (Dali::Vector2 *)jarg1;
5415   if (!arg1) {
5416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5417     return 0;
5418   }
5419   arg2 = (Dali::Vector2 *)jarg2;
5420   if (!arg2) {
5421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5422     return 0;
5423   }
5424   {
5425     try {
5426       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5427     } catch (std::out_of_range& e) {
5428       {
5429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5430       };
5431     } catch (std::exception& e) {
5432       {
5433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5434       };
5435     } catch (Dali::DaliException e) {
5436       {
5437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5438       };
5439     } catch (...) {
5440       {
5441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5442       };
5443     }
5444   }
5445
5446   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5447   return jresult;
5448 }
5449
5450
5451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5452   void * jresult ;
5453   Dali::Vector2 *arg1 = 0 ;
5454   Dali::Vector2 *arg2 = 0 ;
5455   Dali::Vector2 result;
5456
5457   arg1 = (Dali::Vector2 *)jarg1;
5458   if (!arg1) {
5459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5460     return 0;
5461   }
5462   arg2 = (Dali::Vector2 *)jarg2;
5463   if (!arg2) {
5464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5465     return 0;
5466   }
5467   {
5468     try {
5469       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5470     } catch (std::out_of_range& e) {
5471       {
5472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5473       };
5474     } catch (std::exception& e) {
5475       {
5476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5477       };
5478     } catch (Dali::DaliException e) {
5479       {
5480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5481       };
5482     } catch (...) {
5483       {
5484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5485       };
5486     }
5487   }
5488
5489   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5490   return jresult;
5491 }
5492
5493
5494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5495   void * jresult ;
5496   Dali::Vector2 *arg1 = 0 ;
5497   float *arg2 = 0 ;
5498   float *arg3 = 0 ;
5499   float temp2 ;
5500   float temp3 ;
5501   Dali::Vector2 result;
5502
5503   arg1 = (Dali::Vector2 *)jarg1;
5504   if (!arg1) {
5505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5506     return 0;
5507   }
5508   temp2 = (float)jarg2;
5509   arg2 = &temp2;
5510   temp3 = (float)jarg3;
5511   arg3 = &temp3;
5512   {
5513     try {
5514       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5515     } catch (std::out_of_range& e) {
5516       {
5517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5518       };
5519     } catch (std::exception& e) {
5520       {
5521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5522       };
5523     } catch (Dali::DaliException e) {
5524       {
5525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5526       };
5527     } catch (...) {
5528       {
5529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5530       };
5531     }
5532   }
5533
5534   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5535   return jresult;
5536 }
5537
5538
5539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5540   void * jresult ;
5541   Dali::Vector3 *result = 0 ;
5542
5543   {
5544     try {
5545       result = (Dali::Vector3 *)new Dali::Vector3();
5546     } catch (std::out_of_range& e) {
5547       {
5548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5549       };
5550     } catch (std::exception& e) {
5551       {
5552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5553       };
5554     } catch (Dali::DaliException e) {
5555       {
5556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5557       };
5558     } catch (...) {
5559       {
5560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5561       };
5562     }
5563   }
5564
5565   jresult = (void *)result;
5566   return jresult;
5567 }
5568
5569
5570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5571   void * jresult ;
5572   float arg1 ;
5573   float arg2 ;
5574   float arg3 ;
5575   Dali::Vector3 *result = 0 ;
5576
5577   arg1 = (float)jarg1;
5578   arg2 = (float)jarg2;
5579   arg3 = (float)jarg3;
5580   {
5581     try {
5582       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5583     } catch (std::out_of_range& e) {
5584       {
5585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5586       };
5587     } catch (std::exception& e) {
5588       {
5589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5590       };
5591     } catch (Dali::DaliException e) {
5592       {
5593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5594       };
5595     } catch (...) {
5596       {
5597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5598       };
5599     }
5600   }
5601
5602   jresult = (void *)result;
5603   return jresult;
5604 }
5605
5606
5607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5608   void * jresult ;
5609   float *arg1 = (float *) 0 ;
5610   Dali::Vector3 *result = 0 ;
5611
5612   arg1 = jarg1;
5613   {
5614     try {
5615       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5616     } catch (std::out_of_range& e) {
5617       {
5618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5619       };
5620     } catch (std::exception& e) {
5621       {
5622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5623       };
5624     } catch (Dali::DaliException e) {
5625       {
5626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5627       };
5628     } catch (...) {
5629       {
5630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5631       };
5632     }
5633   }
5634
5635   jresult = (void *)result;
5636
5637
5638   return jresult;
5639 }
5640
5641
5642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5643   void * jresult ;
5644   Dali::Vector2 *arg1 = 0 ;
5645   Dali::Vector3 *result = 0 ;
5646
5647   arg1 = (Dali::Vector2 *)jarg1;
5648   if (!arg1) {
5649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5650     return 0;
5651   }
5652   {
5653     try {
5654       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5655     } catch (std::out_of_range& e) {
5656       {
5657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5658       };
5659     } catch (std::exception& e) {
5660       {
5661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5662       };
5663     } catch (Dali::DaliException e) {
5664       {
5665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5666       };
5667     } catch (...) {
5668       {
5669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5670       };
5671     }
5672   }
5673
5674   jresult = (void *)result;
5675   return jresult;
5676 }
5677
5678
5679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5680   void * jresult ;
5681   Dali::Vector4 *arg1 = 0 ;
5682   Dali::Vector3 *result = 0 ;
5683
5684   arg1 = (Dali::Vector4 *)jarg1;
5685   if (!arg1) {
5686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5687     return 0;
5688   }
5689   {
5690     try {
5691       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5692     } catch (std::out_of_range& e) {
5693       {
5694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5695       };
5696     } catch (std::exception& e) {
5697       {
5698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5699       };
5700     } catch (Dali::DaliException e) {
5701       {
5702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5703       };
5704     } catch (...) {
5705       {
5706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5707       };
5708     }
5709   }
5710
5711   jresult = (void *)result;
5712   return jresult;
5713 }
5714
5715
5716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5717   void * jresult ;
5718   Dali::Vector3 *result = 0 ;
5719
5720   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5721   jresult = (void *)result;
5722   return jresult;
5723 }
5724
5725
5726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5727   void * jresult ;
5728   Dali::Vector3 *result = 0 ;
5729
5730   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5731   jresult = (void *)result;
5732   return jresult;
5733 }
5734
5735
5736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5737   void * jresult ;
5738   Dali::Vector3 *result = 0 ;
5739
5740   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5741   jresult = (void *)result;
5742   return jresult;
5743 }
5744
5745
5746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5747   void * jresult ;
5748   Dali::Vector3 *result = 0 ;
5749
5750   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5751   jresult = (void *)result;
5752   return jresult;
5753 }
5754
5755
5756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5757   void * jresult ;
5758   Dali::Vector3 *result = 0 ;
5759
5760   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5761   jresult = (void *)result;
5762   return jresult;
5763 }
5764
5765
5766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5767   void * jresult ;
5768   Dali::Vector3 *result = 0 ;
5769
5770   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5771   jresult = (void *)result;
5772   return jresult;
5773 }
5774
5775
5776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5777   void * jresult ;
5778   Dali::Vector3 *result = 0 ;
5779
5780   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5781   jresult = (void *)result;
5782   return jresult;
5783 }
5784
5785
5786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5787   void * jresult ;
5788   Dali::Vector3 *result = 0 ;
5789
5790   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5791   jresult = (void *)result;
5792   return jresult;
5793 }
5794
5795
5796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5797   void * jresult ;
5798   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5799   float *arg2 = (float *) 0 ;
5800   Dali::Vector3 *result = 0 ;
5801
5802   arg1 = (Dali::Vector3 *)jarg1;
5803   arg2 = jarg2;
5804   {
5805     try {
5806       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5807     } catch (std::out_of_range& e) {
5808       {
5809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5810       };
5811     } catch (std::exception& e) {
5812       {
5813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5814       };
5815     } catch (Dali::DaliException e) {
5816       {
5817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5818       };
5819     } catch (...) {
5820       {
5821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5822       };
5823     }
5824   }
5825
5826   jresult = (void *)result;
5827
5828
5829   return jresult;
5830 }
5831
5832
5833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5834   void * jresult ;
5835   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5836   Dali::Vector2 *arg2 = 0 ;
5837   Dali::Vector3 *result = 0 ;
5838
5839   arg1 = (Dali::Vector3 *)jarg1;
5840   arg2 = (Dali::Vector2 *)jarg2;
5841   if (!arg2) {
5842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5843     return 0;
5844   }
5845   {
5846     try {
5847       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5848     } catch (std::out_of_range& e) {
5849       {
5850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5851       };
5852     } catch (std::exception& e) {
5853       {
5854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5855       };
5856     } catch (Dali::DaliException e) {
5857       {
5858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5859       };
5860     } catch (...) {
5861       {
5862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5863       };
5864     }
5865   }
5866
5867   jresult = (void *)result;
5868   return jresult;
5869 }
5870
5871
5872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5873   void * jresult ;
5874   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5875   Dali::Vector4 *arg2 = 0 ;
5876   Dali::Vector3 *result = 0 ;
5877
5878   arg1 = (Dali::Vector3 *)jarg1;
5879   arg2 = (Dali::Vector4 *)jarg2;
5880   if (!arg2) {
5881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5882     return 0;
5883   }
5884   {
5885     try {
5886       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5887     } catch (std::out_of_range& e) {
5888       {
5889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5890       };
5891     } catch (std::exception& e) {
5892       {
5893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5894       };
5895     } catch (Dali::DaliException e) {
5896       {
5897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5898       };
5899     } catch (...) {
5900       {
5901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5902       };
5903     }
5904   }
5905
5906   jresult = (void *)result;
5907   return jresult;
5908 }
5909
5910
5911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5912   void * jresult ;
5913   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5914   Dali::Vector3 *arg2 = 0 ;
5915   Dali::Vector3 result;
5916
5917   arg1 = (Dali::Vector3 *)jarg1;
5918   arg2 = (Dali::Vector3 *)jarg2;
5919   if (!arg2) {
5920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5921     return 0;
5922   }
5923   {
5924     try {
5925       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5926     } catch (std::out_of_range& e) {
5927       {
5928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5929       };
5930     } catch (std::exception& e) {
5931       {
5932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5933       };
5934     } catch (Dali::DaliException e) {
5935       {
5936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5937       };
5938     } catch (...) {
5939       {
5940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5941       };
5942     }
5943   }
5944
5945   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5946   return jresult;
5947 }
5948
5949
5950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5951   void * jresult ;
5952   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5953   Dali::Vector3 *arg2 = 0 ;
5954   Dali::Vector3 *result = 0 ;
5955
5956   arg1 = (Dali::Vector3 *)jarg1;
5957   arg2 = (Dali::Vector3 *)jarg2;
5958   if (!arg2) {
5959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5960     return 0;
5961   }
5962   {
5963     try {
5964       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5965     } catch (std::out_of_range& e) {
5966       {
5967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5968       };
5969     } catch (std::exception& e) {
5970       {
5971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5972       };
5973     } catch (Dali::DaliException e) {
5974       {
5975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5976       };
5977     } catch (...) {
5978       {
5979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5980       };
5981     }
5982   }
5983
5984   jresult = (void *)result;
5985   return jresult;
5986 }
5987
5988
5989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5990   void * jresult ;
5991   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5992   Dali::Vector3 *arg2 = 0 ;
5993   Dali::Vector3 result;
5994
5995   arg1 = (Dali::Vector3 *)jarg1;
5996   arg2 = (Dali::Vector3 *)jarg2;
5997   if (!arg2) {
5998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5999     return 0;
6000   }
6001   {
6002     try {
6003       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6004     } catch (std::out_of_range& e) {
6005       {
6006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6007       };
6008     } catch (std::exception& e) {
6009       {
6010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6011       };
6012     } catch (Dali::DaliException e) {
6013       {
6014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6015       };
6016     } catch (...) {
6017       {
6018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6019       };
6020     }
6021   }
6022
6023   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6024   return jresult;
6025 }
6026
6027
6028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6029   void * jresult ;
6030   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6031   Dali::Vector3 *arg2 = 0 ;
6032   Dali::Vector3 *result = 0 ;
6033
6034   arg1 = (Dali::Vector3 *)jarg1;
6035   arg2 = (Dali::Vector3 *)jarg2;
6036   if (!arg2) {
6037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6038     return 0;
6039   }
6040   {
6041     try {
6042       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6043     } catch (std::out_of_range& e) {
6044       {
6045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6046       };
6047     } catch (std::exception& e) {
6048       {
6049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6050       };
6051     } catch (Dali::DaliException e) {
6052       {
6053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6054       };
6055     } catch (...) {
6056       {
6057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6058       };
6059     }
6060   }
6061
6062   jresult = (void *)result;
6063   return jresult;
6064 }
6065
6066
6067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6068   void * jresult ;
6069   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6070   Dali::Vector3 *arg2 = 0 ;
6071   Dali::Vector3 result;
6072
6073   arg1 = (Dali::Vector3 *)jarg1;
6074   arg2 = (Dali::Vector3 *)jarg2;
6075   if (!arg2) {
6076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6077     return 0;
6078   }
6079   {
6080     try {
6081       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6082     } catch (std::out_of_range& e) {
6083       {
6084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6085       };
6086     } catch (std::exception& e) {
6087       {
6088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6089       };
6090     } catch (Dali::DaliException e) {
6091       {
6092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6093       };
6094     } catch (...) {
6095       {
6096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6097       };
6098     }
6099   }
6100
6101   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6102   return jresult;
6103 }
6104
6105
6106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6107   void * jresult ;
6108   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6109   float arg2 ;
6110   Dali::Vector3 result;
6111
6112   arg1 = (Dali::Vector3 *)jarg1;
6113   arg2 = (float)jarg2;
6114   {
6115     try {
6116       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6117     } catch (std::out_of_range& e) {
6118       {
6119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6120       };
6121     } catch (std::exception& e) {
6122       {
6123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6124       };
6125     } catch (Dali::DaliException e) {
6126       {
6127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6128       };
6129     } catch (...) {
6130       {
6131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6132       };
6133     }
6134   }
6135
6136   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6137   return jresult;
6138 }
6139
6140
6141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6142   void * jresult ;
6143   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6144   Dali::Vector3 *arg2 = 0 ;
6145   Dali::Vector3 *result = 0 ;
6146
6147   arg1 = (Dali::Vector3 *)jarg1;
6148   arg2 = (Dali::Vector3 *)jarg2;
6149   if (!arg2) {
6150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6151     return 0;
6152   }
6153   {
6154     try {
6155       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6156     } catch (std::out_of_range& e) {
6157       {
6158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6159       };
6160     } catch (std::exception& e) {
6161       {
6162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6163       };
6164     } catch (Dali::DaliException e) {
6165       {
6166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6167       };
6168     } catch (...) {
6169       {
6170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6171       };
6172     }
6173   }
6174
6175   jresult = (void *)result;
6176   return jresult;
6177 }
6178
6179
6180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6181   void * jresult ;
6182   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6183   float arg2 ;
6184   Dali::Vector3 *result = 0 ;
6185
6186   arg1 = (Dali::Vector3 *)jarg1;
6187   arg2 = (float)jarg2;
6188   {
6189     try {
6190       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6191     } catch (std::out_of_range& e) {
6192       {
6193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6194       };
6195     } catch (std::exception& e) {
6196       {
6197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6198       };
6199     } catch (Dali::DaliException e) {
6200       {
6201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6202       };
6203     } catch (...) {
6204       {
6205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6206       };
6207     }
6208   }
6209
6210   jresult = (void *)result;
6211   return jresult;
6212 }
6213
6214
6215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6216   void * jresult ;
6217   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6218   Dali::Quaternion *arg2 = 0 ;
6219   Dali::Vector3 *result = 0 ;
6220
6221   arg1 = (Dali::Vector3 *)jarg1;
6222   arg2 = (Dali::Quaternion *)jarg2;
6223   if (!arg2) {
6224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6225     return 0;
6226   }
6227   {
6228     try {
6229       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6230     } catch (std::out_of_range& e) {
6231       {
6232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6233       };
6234     } catch (std::exception& e) {
6235       {
6236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6237       };
6238     } catch (Dali::DaliException e) {
6239       {
6240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6241       };
6242     } catch (...) {
6243       {
6244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6245       };
6246     }
6247   }
6248
6249   jresult = (void *)result;
6250   return jresult;
6251 }
6252
6253
6254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6255   void * jresult ;
6256   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6257   Dali::Vector3 *arg2 = 0 ;
6258   Dali::Vector3 result;
6259
6260   arg1 = (Dali::Vector3 *)jarg1;
6261   arg2 = (Dali::Vector3 *)jarg2;
6262   if (!arg2) {
6263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6264     return 0;
6265   }
6266   {
6267     try {
6268       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6269     } catch (std::out_of_range& e) {
6270       {
6271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6272       };
6273     } catch (std::exception& e) {
6274       {
6275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6276       };
6277     } catch (Dali::DaliException e) {
6278       {
6279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6280       };
6281     } catch (...) {
6282       {
6283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6284       };
6285     }
6286   }
6287
6288   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6289   return jresult;
6290 }
6291
6292
6293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6294   void * jresult ;
6295   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6296   float arg2 ;
6297   Dali::Vector3 result;
6298
6299   arg1 = (Dali::Vector3 *)jarg1;
6300   arg2 = (float)jarg2;
6301   {
6302     try {
6303       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6304     } catch (std::out_of_range& e) {
6305       {
6306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6307       };
6308     } catch (std::exception& e) {
6309       {
6310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6311       };
6312     } catch (Dali::DaliException e) {
6313       {
6314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6315       };
6316     } catch (...) {
6317       {
6318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6319       };
6320     }
6321   }
6322
6323   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6324   return jresult;
6325 }
6326
6327
6328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6329   void * jresult ;
6330   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6331   Dali::Vector3 *arg2 = 0 ;
6332   Dali::Vector3 *result = 0 ;
6333
6334   arg1 = (Dali::Vector3 *)jarg1;
6335   arg2 = (Dali::Vector3 *)jarg2;
6336   if (!arg2) {
6337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6338     return 0;
6339   }
6340   {
6341     try {
6342       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6343     } catch (std::out_of_range& e) {
6344       {
6345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6346       };
6347     } catch (std::exception& e) {
6348       {
6349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6350       };
6351     } catch (Dali::DaliException e) {
6352       {
6353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6354       };
6355     } catch (...) {
6356       {
6357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6358       };
6359     }
6360   }
6361
6362   jresult = (void *)result;
6363   return jresult;
6364 }
6365
6366
6367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6368   void * jresult ;
6369   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6370   float arg2 ;
6371   Dali::Vector3 *result = 0 ;
6372
6373   arg1 = (Dali::Vector3 *)jarg1;
6374   arg2 = (float)jarg2;
6375   {
6376     try {
6377       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6378     } catch (std::out_of_range& e) {
6379       {
6380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6381       };
6382     } catch (std::exception& e) {
6383       {
6384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6385       };
6386     } catch (Dali::DaliException e) {
6387       {
6388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6389       };
6390     } catch (...) {
6391       {
6392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6393       };
6394     }
6395   }
6396
6397   jresult = (void *)result;
6398   return jresult;
6399 }
6400
6401
6402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6403   void * jresult ;
6404   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6405   Dali::Vector3 result;
6406
6407   arg1 = (Dali::Vector3 *)jarg1;
6408   {
6409     try {
6410       result = ((Dali::Vector3 const *)arg1)->operator -();
6411     } catch (std::out_of_range& e) {
6412       {
6413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6414       };
6415     } catch (std::exception& e) {
6416       {
6417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6418       };
6419     } catch (Dali::DaliException e) {
6420       {
6421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6422       };
6423     } catch (...) {
6424       {
6425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6426       };
6427     }
6428   }
6429
6430   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6431   return jresult;
6432 }
6433
6434
6435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6436   unsigned int jresult ;
6437   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6438   Dali::Vector3 *arg2 = 0 ;
6439   bool result;
6440
6441   arg1 = (Dali::Vector3 *)jarg1;
6442   arg2 = (Dali::Vector3 *)jarg2;
6443   if (!arg2) {
6444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6445     return 0;
6446   }
6447   {
6448     try {
6449       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6450     } catch (std::out_of_range& e) {
6451       {
6452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6453       };
6454     } catch (std::exception& e) {
6455       {
6456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6457       };
6458     } catch (Dali::DaliException e) {
6459       {
6460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6461       };
6462     } catch (...) {
6463       {
6464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6465       };
6466     }
6467   }
6468
6469   jresult = result;
6470   return jresult;
6471 }
6472
6473
6474 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6475   unsigned int jresult ;
6476   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6477   Dali::Vector3 *arg2 = 0 ;
6478   bool result;
6479
6480   arg1 = (Dali::Vector3 *)jarg1;
6481   arg2 = (Dali::Vector3 *)jarg2;
6482   if (!arg2) {
6483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6484     return 0;
6485   }
6486   {
6487     try {
6488       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6489     } catch (std::out_of_range& e) {
6490       {
6491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6492       };
6493     } catch (std::exception& e) {
6494       {
6495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6496       };
6497     } catch (Dali::DaliException e) {
6498       {
6499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6500       };
6501     } catch (...) {
6502       {
6503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6504       };
6505     }
6506   }
6507
6508   jresult = result;
6509   return jresult;
6510 }
6511
6512
6513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6514   float jresult ;
6515   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6516   unsigned int arg2 ;
6517   float *result = 0 ;
6518
6519   arg1 = (Dali::Vector3 *)jarg1;
6520   arg2 = (unsigned int)jarg2;
6521   {
6522     try {
6523       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6524     } catch (std::out_of_range& e) {
6525       {
6526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6527       };
6528     } catch (std::exception& e) {
6529       {
6530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6531       };
6532     } catch (Dali::DaliException e) {
6533       {
6534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6535       };
6536     } catch (...) {
6537       {
6538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6539       };
6540     }
6541   }
6542
6543   jresult = *result;
6544   return jresult;
6545 }
6546
6547
6548 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6549   float jresult ;
6550   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6551   Dali::Vector3 *arg2 = 0 ;
6552   float result;
6553
6554   arg1 = (Dali::Vector3 *)jarg1;
6555   arg2 = (Dali::Vector3 *)jarg2;
6556   if (!arg2) {
6557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6558     return 0;
6559   }
6560   {
6561     try {
6562       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6563     } catch (std::out_of_range& e) {
6564       {
6565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6566       };
6567     } catch (std::exception& e) {
6568       {
6569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6570       };
6571     } catch (Dali::DaliException e) {
6572       {
6573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6574       };
6575     } catch (...) {
6576       {
6577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6578       };
6579     }
6580   }
6581
6582   jresult = result;
6583   return jresult;
6584 }
6585
6586
6587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6588   void * jresult ;
6589   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6590   Dali::Vector3 *arg2 = 0 ;
6591   Dali::Vector3 result;
6592
6593   arg1 = (Dali::Vector3 *)jarg1;
6594   arg2 = (Dali::Vector3 *)jarg2;
6595   if (!arg2) {
6596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6597     return 0;
6598   }
6599   {
6600     try {
6601       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6602     } catch (std::out_of_range& e) {
6603       {
6604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6605       };
6606     } catch (std::exception& e) {
6607       {
6608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6609       };
6610     } catch (Dali::DaliException e) {
6611       {
6612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6613       };
6614     } catch (...) {
6615       {
6616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6617       };
6618     }
6619   }
6620
6621   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6622   return jresult;
6623 }
6624
6625
6626 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6627   float jresult ;
6628   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6629   float result;
6630
6631   arg1 = (Dali::Vector3 *)jarg1;
6632   {
6633     try {
6634       result = (float)((Dali::Vector3 const *)arg1)->Length();
6635     } catch (std::out_of_range& e) {
6636       {
6637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6638       };
6639     } catch (std::exception& e) {
6640       {
6641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6642       };
6643     } catch (Dali::DaliException e) {
6644       {
6645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6646       };
6647     } catch (...) {
6648       {
6649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6650       };
6651     }
6652   }
6653
6654   jresult = result;
6655   return jresult;
6656 }
6657
6658
6659 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6660   float jresult ;
6661   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6662   float result;
6663
6664   arg1 = (Dali::Vector3 *)jarg1;
6665   {
6666     try {
6667       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6668     } catch (std::out_of_range& e) {
6669       {
6670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6671       };
6672     } catch (std::exception& e) {
6673       {
6674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6675       };
6676     } catch (Dali::DaliException e) {
6677       {
6678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6679       };
6680     } catch (...) {
6681       {
6682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6683       };
6684     }
6685   }
6686
6687   jresult = result;
6688   return jresult;
6689 }
6690
6691
6692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6693   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6694
6695   arg1 = (Dali::Vector3 *)jarg1;
6696   {
6697     try {
6698       (arg1)->Normalize();
6699     } catch (std::out_of_range& e) {
6700       {
6701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6702       };
6703     } catch (std::exception& e) {
6704       {
6705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6706       };
6707     } catch (Dali::DaliException e) {
6708       {
6709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6710       };
6711     } catch (...) {
6712       {
6713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6714       };
6715     }
6716   }
6717
6718 }
6719
6720
6721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6722   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6723   Dali::Vector3 *arg2 = 0 ;
6724   Dali::Vector3 *arg3 = 0 ;
6725
6726   arg1 = (Dali::Vector3 *)jarg1;
6727   arg2 = (Dali::Vector3 *)jarg2;
6728   if (!arg2) {
6729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6730     return ;
6731   }
6732   arg3 = (Dali::Vector3 *)jarg3;
6733   if (!arg3) {
6734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6735     return ;
6736   }
6737   {
6738     try {
6739       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6740     } catch (std::out_of_range& e) {
6741       {
6742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6743       };
6744     } catch (std::exception& e) {
6745       {
6746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6747       };
6748     } catch (Dali::DaliException e) {
6749       {
6750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6751       };
6752     } catch (...) {
6753       {
6754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6755       };
6756     }
6757   }
6758
6759 }
6760
6761
6762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6763   void * jresult ;
6764   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6765   float *result = 0 ;
6766
6767   arg1 = (Dali::Vector3 *)jarg1;
6768   {
6769     try {
6770       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6771     } catch (std::out_of_range& e) {
6772       {
6773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6774       };
6775     } catch (std::exception& e) {
6776       {
6777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6778       };
6779     } catch (Dali::DaliException e) {
6780       {
6781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6782       };
6783     } catch (...) {
6784       {
6785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6786       };
6787     }
6788   }
6789
6790   jresult = (void *)result;
6791   return jresult;
6792 }
6793
6794
6795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6796   void * jresult ;
6797   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6798   Dali::Vector2 *result = 0 ;
6799
6800   arg1 = (Dali::Vector3 *)jarg1;
6801   {
6802     try {
6803       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6804     } catch (std::out_of_range& e) {
6805       {
6806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6807       };
6808     } catch (std::exception& e) {
6809       {
6810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6811       };
6812     } catch (Dali::DaliException e) {
6813       {
6814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6815       };
6816     } catch (...) {
6817       {
6818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6819       };
6820     }
6821   }
6822
6823   jresult = (void *)result;
6824   return jresult;
6825 }
6826
6827
6828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6829   void * jresult ;
6830   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6831   Dali::Vector2 *result = 0 ;
6832
6833   arg1 = (Dali::Vector3 *)jarg1;
6834   {
6835     try {
6836       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6837     } catch (std::out_of_range& e) {
6838       {
6839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6840       };
6841     } catch (std::exception& e) {
6842       {
6843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6844       };
6845     } catch (Dali::DaliException e) {
6846       {
6847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6848       };
6849     } catch (...) {
6850       {
6851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6852       };
6853     }
6854   }
6855
6856   jresult = (void *)result;
6857   return jresult;
6858 }
6859
6860
6861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6862   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6863   float arg2 ;
6864
6865   arg1 = (Dali::Vector3 *)jarg1;
6866   arg2 = (float)jarg2;
6867   if (arg1) (arg1)->x = arg2;
6868 }
6869
6870
6871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6872   float jresult ;
6873   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6874   float result;
6875
6876   arg1 = (Dali::Vector3 *)jarg1;
6877   result = (float) ((arg1)->x);
6878   jresult = result;
6879   return jresult;
6880 }
6881
6882
6883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6884   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6885   float arg2 ;
6886
6887   arg1 = (Dali::Vector3 *)jarg1;
6888   arg2 = (float)jarg2;
6889   if (arg1) (arg1)->width = arg2;
6890 }
6891
6892
6893 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6894   float jresult ;
6895   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6896   float result;
6897
6898   arg1 = (Dali::Vector3 *)jarg1;
6899   result = (float) ((arg1)->width);
6900   jresult = result;
6901   return jresult;
6902 }
6903
6904
6905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6906   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6907   float arg2 ;
6908
6909   arg1 = (Dali::Vector3 *)jarg1;
6910   arg2 = (float)jarg2;
6911   if (arg1) (arg1)->r = arg2;
6912 }
6913
6914
6915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6916   float jresult ;
6917   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6918   float result;
6919
6920   arg1 = (Dali::Vector3 *)jarg1;
6921   result = (float) ((arg1)->r);
6922   jresult = result;
6923   return jresult;
6924 }
6925
6926
6927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6928   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6929   float arg2 ;
6930
6931   arg1 = (Dali::Vector3 *)jarg1;
6932   arg2 = (float)jarg2;
6933   if (arg1) (arg1)->y = arg2;
6934 }
6935
6936
6937 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6938   float jresult ;
6939   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6940   float result;
6941
6942   arg1 = (Dali::Vector3 *)jarg1;
6943   result = (float) ((arg1)->y);
6944   jresult = result;
6945   return jresult;
6946 }
6947
6948
6949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6950   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6951   float arg2 ;
6952
6953   arg1 = (Dali::Vector3 *)jarg1;
6954   arg2 = (float)jarg2;
6955   if (arg1) (arg1)->height = arg2;
6956 }
6957
6958
6959 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6960   float jresult ;
6961   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6962   float result;
6963
6964   arg1 = (Dali::Vector3 *)jarg1;
6965   result = (float) ((arg1)->height);
6966   jresult = result;
6967   return jresult;
6968 }
6969
6970
6971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6972   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6973   float arg2 ;
6974
6975   arg1 = (Dali::Vector3 *)jarg1;
6976   arg2 = (float)jarg2;
6977   if (arg1) (arg1)->g = arg2;
6978 }
6979
6980
6981 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6982   float jresult ;
6983   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6984   float result;
6985
6986   arg1 = (Dali::Vector3 *)jarg1;
6987   result = (float) ((arg1)->g);
6988   jresult = result;
6989   return jresult;
6990 }
6991
6992
6993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6994   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6995   float arg2 ;
6996
6997   arg1 = (Dali::Vector3 *)jarg1;
6998   arg2 = (float)jarg2;
6999   if (arg1) (arg1)->z = arg2;
7000 }
7001
7002
7003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7004   float jresult ;
7005   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7006   float result;
7007
7008   arg1 = (Dali::Vector3 *)jarg1;
7009   result = (float) ((arg1)->z);
7010   jresult = result;
7011   return jresult;
7012 }
7013
7014
7015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7016   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7017   float arg2 ;
7018
7019   arg1 = (Dali::Vector3 *)jarg1;
7020   arg2 = (float)jarg2;
7021   if (arg1) (arg1)->depth = arg2;
7022 }
7023
7024
7025 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7026   float jresult ;
7027   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7028   float result;
7029
7030   arg1 = (Dali::Vector3 *)jarg1;
7031   result = (float) ((arg1)->depth);
7032   jresult = result;
7033   return jresult;
7034 }
7035
7036
7037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7038   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7039   float arg2 ;
7040
7041   arg1 = (Dali::Vector3 *)jarg1;
7042   arg2 = (float)jarg2;
7043   if (arg1) (arg1)->b = arg2;
7044 }
7045
7046
7047 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7048   float jresult ;
7049   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7050   float result;
7051
7052   arg1 = (Dali::Vector3 *)jarg1;
7053   result = (float) ((arg1)->b);
7054   jresult = result;
7055   return jresult;
7056 }
7057
7058
7059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7060   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7061
7062   arg1 = (Dali::Vector3 *)jarg1;
7063   {
7064     try {
7065       delete arg1;
7066     } catch (std::out_of_range& e) {
7067       {
7068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7069       };
7070     } catch (std::exception& e) {
7071       {
7072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7073       };
7074     } catch (Dali::DaliException e) {
7075       {
7076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7077       };
7078     } catch (...) {
7079       {
7080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7081       };
7082     }
7083   }
7084
7085 }
7086
7087
7088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7089   void * jresult ;
7090   Dali::Vector3 *arg1 = 0 ;
7091   Dali::Vector3 *arg2 = 0 ;
7092   Dali::Vector3 result;
7093
7094   arg1 = (Dali::Vector3 *)jarg1;
7095   if (!arg1) {
7096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7097     return 0;
7098   }
7099   arg2 = (Dali::Vector3 *)jarg2;
7100   if (!arg2) {
7101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7102     return 0;
7103   }
7104   {
7105     try {
7106       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7107     } catch (std::out_of_range& e) {
7108       {
7109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7110       };
7111     } catch (std::exception& e) {
7112       {
7113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7114       };
7115     } catch (Dali::DaliException e) {
7116       {
7117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7118       };
7119     } catch (...) {
7120       {
7121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7122       };
7123     }
7124   }
7125
7126   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7127   return jresult;
7128 }
7129
7130
7131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7132   void * jresult ;
7133   Dali::Vector3 *arg1 = 0 ;
7134   Dali::Vector3 *arg2 = 0 ;
7135   Dali::Vector3 result;
7136
7137   arg1 = (Dali::Vector3 *)jarg1;
7138   if (!arg1) {
7139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7140     return 0;
7141   }
7142   arg2 = (Dali::Vector3 *)jarg2;
7143   if (!arg2) {
7144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7145     return 0;
7146   }
7147   {
7148     try {
7149       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7150     } catch (std::out_of_range& e) {
7151       {
7152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7153       };
7154     } catch (std::exception& e) {
7155       {
7156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7157       };
7158     } catch (Dali::DaliException e) {
7159       {
7160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7161       };
7162     } catch (...) {
7163       {
7164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7165       };
7166     }
7167   }
7168
7169   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7170   return jresult;
7171 }
7172
7173
7174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7175   void * jresult ;
7176   Dali::Vector3 *arg1 = 0 ;
7177   float *arg2 = 0 ;
7178   float *arg3 = 0 ;
7179   float temp2 ;
7180   float temp3 ;
7181   Dali::Vector3 result;
7182
7183   arg1 = (Dali::Vector3 *)jarg1;
7184   if (!arg1) {
7185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7186     return 0;
7187   }
7188   temp2 = (float)jarg2;
7189   arg2 = &temp2;
7190   temp3 = (float)jarg3;
7191   arg3 = &temp3;
7192   {
7193     try {
7194       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7195     } catch (std::out_of_range& e) {
7196       {
7197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7198       };
7199     } catch (std::exception& e) {
7200       {
7201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7202       };
7203     } catch (Dali::DaliException e) {
7204       {
7205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7206       };
7207     } catch (...) {
7208       {
7209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7210       };
7211     }
7212   }
7213
7214   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7215   return jresult;
7216 }
7217
7218
7219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7220   void * jresult ;
7221   Dali::Vector4 *result = 0 ;
7222
7223   {
7224     try {
7225       result = (Dali::Vector4 *)new Dali::Vector4();
7226     } catch (std::out_of_range& e) {
7227       {
7228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7229       };
7230     } catch (std::exception& e) {
7231       {
7232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7233       };
7234     } catch (Dali::DaliException e) {
7235       {
7236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7237       };
7238     } catch (...) {
7239       {
7240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7241       };
7242     }
7243   }
7244
7245   jresult = (void *)result;
7246   return jresult;
7247 }
7248
7249
7250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7251   void * jresult ;
7252   float arg1 ;
7253   float arg2 ;
7254   float arg3 ;
7255   float arg4 ;
7256   Dali::Vector4 *result = 0 ;
7257
7258   arg1 = (float)jarg1;
7259   arg2 = (float)jarg2;
7260   arg3 = (float)jarg3;
7261   arg4 = (float)jarg4;
7262   {
7263     try {
7264       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7265     } catch (std::out_of_range& e) {
7266       {
7267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7268       };
7269     } catch (std::exception& e) {
7270       {
7271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7272       };
7273     } catch (Dali::DaliException e) {
7274       {
7275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7276       };
7277     } catch (...) {
7278       {
7279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7280       };
7281     }
7282   }
7283
7284   jresult = (void *)result;
7285   return jresult;
7286 }
7287
7288
7289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7290   void * jresult ;
7291   float *arg1 = (float *) 0 ;
7292   Dali::Vector4 *result = 0 ;
7293
7294   arg1 = jarg1;
7295   {
7296     try {
7297       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7298     } catch (std::out_of_range& e) {
7299       {
7300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7301       };
7302     } catch (std::exception& e) {
7303       {
7304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7305       };
7306     } catch (Dali::DaliException e) {
7307       {
7308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7309       };
7310     } catch (...) {
7311       {
7312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7313       };
7314     }
7315   }
7316
7317   jresult = (void *)result;
7318
7319
7320   return jresult;
7321 }
7322
7323
7324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7325   void * jresult ;
7326   Dali::Vector2 *arg1 = 0 ;
7327   Dali::Vector4 *result = 0 ;
7328
7329   arg1 = (Dali::Vector2 *)jarg1;
7330   if (!arg1) {
7331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7332     return 0;
7333   }
7334   {
7335     try {
7336       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7337     } catch (std::out_of_range& e) {
7338       {
7339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7340       };
7341     } catch (std::exception& e) {
7342       {
7343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7344       };
7345     } catch (Dali::DaliException e) {
7346       {
7347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7348       };
7349     } catch (...) {
7350       {
7351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7352       };
7353     }
7354   }
7355
7356   jresult = (void *)result;
7357   return jresult;
7358 }
7359
7360
7361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7362   void * jresult ;
7363   Dali::Vector3 *arg1 = 0 ;
7364   Dali::Vector4 *result = 0 ;
7365
7366   arg1 = (Dali::Vector3 *)jarg1;
7367   if (!arg1) {
7368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7369     return 0;
7370   }
7371   {
7372     try {
7373       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7374     } catch (std::out_of_range& e) {
7375       {
7376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7377       };
7378     } catch (std::exception& e) {
7379       {
7380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7381       };
7382     } catch (Dali::DaliException e) {
7383       {
7384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7385       };
7386     } catch (...) {
7387       {
7388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7389       };
7390     }
7391   }
7392
7393   jresult = (void *)result;
7394   return jresult;
7395 }
7396
7397
7398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7399   void * jresult ;
7400   Dali::Vector4 *result = 0 ;
7401
7402   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7403   jresult = (void *)result;
7404   return jresult;
7405 }
7406
7407
7408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7409   void * jresult ;
7410   Dali::Vector4 *result = 0 ;
7411
7412   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7413   jresult = (void *)result;
7414   return jresult;
7415 }
7416
7417
7418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7419   void * jresult ;
7420   Dali::Vector4 *result = 0 ;
7421
7422   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7423   jresult = (void *)result;
7424   return jresult;
7425 }
7426
7427
7428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7429   void * jresult ;
7430   Dali::Vector4 *result = 0 ;
7431
7432   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7433   jresult = (void *)result;
7434   return jresult;
7435 }
7436
7437
7438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7439   void * jresult ;
7440   Dali::Vector4 *result = 0 ;
7441
7442   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7443   jresult = (void *)result;
7444   return jresult;
7445 }
7446
7447
7448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7449   void * jresult ;
7450   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7451   float *arg2 = (float *) 0 ;
7452   Dali::Vector4 *result = 0 ;
7453
7454   arg1 = (Dali::Vector4 *)jarg1;
7455   arg2 = jarg2;
7456   {
7457     try {
7458       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7459     } catch (std::out_of_range& e) {
7460       {
7461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7462       };
7463     } catch (std::exception& e) {
7464       {
7465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7466       };
7467     } catch (Dali::DaliException e) {
7468       {
7469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7470       };
7471     } catch (...) {
7472       {
7473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7474       };
7475     }
7476   }
7477
7478   jresult = (void *)result;
7479
7480
7481   return jresult;
7482 }
7483
7484
7485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7486   void * jresult ;
7487   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7488   Dali::Vector2 *arg2 = 0 ;
7489   Dali::Vector4 *result = 0 ;
7490
7491   arg1 = (Dali::Vector4 *)jarg1;
7492   arg2 = (Dali::Vector2 *)jarg2;
7493   if (!arg2) {
7494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7495     return 0;
7496   }
7497   {
7498     try {
7499       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7500     } catch (std::out_of_range& e) {
7501       {
7502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7503       };
7504     } catch (std::exception& e) {
7505       {
7506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7507       };
7508     } catch (Dali::DaliException e) {
7509       {
7510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7511       };
7512     } catch (...) {
7513       {
7514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7515       };
7516     }
7517   }
7518
7519   jresult = (void *)result;
7520   return jresult;
7521 }
7522
7523
7524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7525   void * jresult ;
7526   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7527   Dali::Vector3 *arg2 = 0 ;
7528   Dali::Vector4 *result = 0 ;
7529
7530   arg1 = (Dali::Vector4 *)jarg1;
7531   arg2 = (Dali::Vector3 *)jarg2;
7532   if (!arg2) {
7533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7534     return 0;
7535   }
7536   {
7537     try {
7538       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7539     } catch (std::out_of_range& e) {
7540       {
7541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7542       };
7543     } catch (std::exception& e) {
7544       {
7545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7546       };
7547     } catch (Dali::DaliException e) {
7548       {
7549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7550       };
7551     } catch (...) {
7552       {
7553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7554       };
7555     }
7556   }
7557
7558   jresult = (void *)result;
7559   return jresult;
7560 }
7561
7562
7563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7564   void * jresult ;
7565   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7566   Dali::Vector4 *arg2 = 0 ;
7567   Dali::Vector4 result;
7568
7569   arg1 = (Dali::Vector4 *)jarg1;
7570   arg2 = (Dali::Vector4 *)jarg2;
7571   if (!arg2) {
7572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7573     return 0;
7574   }
7575   {
7576     try {
7577       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7578     } catch (std::out_of_range& e) {
7579       {
7580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7581       };
7582     } catch (std::exception& e) {
7583       {
7584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7585       };
7586     } catch (Dali::DaliException e) {
7587       {
7588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7589       };
7590     } catch (...) {
7591       {
7592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7593       };
7594     }
7595   }
7596
7597   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7598   return jresult;
7599 }
7600
7601
7602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7603   void * jresult ;
7604   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7605   Dali::Vector4 *arg2 = 0 ;
7606   Dali::Vector4 *result = 0 ;
7607
7608   arg1 = (Dali::Vector4 *)jarg1;
7609   arg2 = (Dali::Vector4 *)jarg2;
7610   if (!arg2) {
7611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7612     return 0;
7613   }
7614   {
7615     try {
7616       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7617     } catch (std::out_of_range& e) {
7618       {
7619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7620       };
7621     } catch (std::exception& e) {
7622       {
7623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7624       };
7625     } catch (Dali::DaliException e) {
7626       {
7627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7628       };
7629     } catch (...) {
7630       {
7631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7632       };
7633     }
7634   }
7635
7636   jresult = (void *)result;
7637   return jresult;
7638 }
7639
7640
7641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7642   void * jresult ;
7643   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7644   Dali::Vector4 *arg2 = 0 ;
7645   Dali::Vector4 result;
7646
7647   arg1 = (Dali::Vector4 *)jarg1;
7648   arg2 = (Dali::Vector4 *)jarg2;
7649   if (!arg2) {
7650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7651     return 0;
7652   }
7653   {
7654     try {
7655       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7656     } catch (std::out_of_range& e) {
7657       {
7658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7659       };
7660     } catch (std::exception& e) {
7661       {
7662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7663       };
7664     } catch (Dali::DaliException e) {
7665       {
7666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7667       };
7668     } catch (...) {
7669       {
7670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7671       };
7672     }
7673   }
7674
7675   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7676   return jresult;
7677 }
7678
7679
7680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7681   void * jresult ;
7682   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7683   Dali::Vector4 *arg2 = 0 ;
7684   Dali::Vector4 *result = 0 ;
7685
7686   arg1 = (Dali::Vector4 *)jarg1;
7687   arg2 = (Dali::Vector4 *)jarg2;
7688   if (!arg2) {
7689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7690     return 0;
7691   }
7692   {
7693     try {
7694       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7695     } catch (std::out_of_range& e) {
7696       {
7697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7698       };
7699     } catch (std::exception& e) {
7700       {
7701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7702       };
7703     } catch (Dali::DaliException e) {
7704       {
7705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7706       };
7707     } catch (...) {
7708       {
7709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7710       };
7711     }
7712   }
7713
7714   jresult = (void *)result;
7715   return jresult;
7716 }
7717
7718
7719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7720   void * jresult ;
7721   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7722   Dali::Vector4 *arg2 = 0 ;
7723   Dali::Vector4 result;
7724
7725   arg1 = (Dali::Vector4 *)jarg1;
7726   arg2 = (Dali::Vector4 *)jarg2;
7727   if (!arg2) {
7728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7729     return 0;
7730   }
7731   {
7732     try {
7733       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7734     } catch (std::out_of_range& e) {
7735       {
7736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7737       };
7738     } catch (std::exception& e) {
7739       {
7740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7741       };
7742     } catch (Dali::DaliException e) {
7743       {
7744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7745       };
7746     } catch (...) {
7747       {
7748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7749       };
7750     }
7751   }
7752
7753   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7754   return jresult;
7755 }
7756
7757
7758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7759   void * jresult ;
7760   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7761   float arg2 ;
7762   Dali::Vector4 result;
7763
7764   arg1 = (Dali::Vector4 *)jarg1;
7765   arg2 = (float)jarg2;
7766   {
7767     try {
7768       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7769     } catch (std::out_of_range& e) {
7770       {
7771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7772       };
7773     } catch (std::exception& e) {
7774       {
7775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7776       };
7777     } catch (Dali::DaliException e) {
7778       {
7779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7780       };
7781     } catch (...) {
7782       {
7783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7784       };
7785     }
7786   }
7787
7788   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7789   return jresult;
7790 }
7791
7792
7793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7794   void * jresult ;
7795   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7796   Dali::Vector4 *arg2 = 0 ;
7797   Dali::Vector4 *result = 0 ;
7798
7799   arg1 = (Dali::Vector4 *)jarg1;
7800   arg2 = (Dali::Vector4 *)jarg2;
7801   if (!arg2) {
7802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7803     return 0;
7804   }
7805   {
7806     try {
7807       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7808     } catch (std::out_of_range& e) {
7809       {
7810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7811       };
7812     } catch (std::exception& e) {
7813       {
7814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7815       };
7816     } catch (Dali::DaliException e) {
7817       {
7818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7819       };
7820     } catch (...) {
7821       {
7822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7823       };
7824     }
7825   }
7826
7827   jresult = (void *)result;
7828   return jresult;
7829 }
7830
7831
7832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7833   void * jresult ;
7834   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7835   float arg2 ;
7836   Dali::Vector4 *result = 0 ;
7837
7838   arg1 = (Dali::Vector4 *)jarg1;
7839   arg2 = (float)jarg2;
7840   {
7841     try {
7842       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7843     } catch (std::out_of_range& e) {
7844       {
7845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7846       };
7847     } catch (std::exception& e) {
7848       {
7849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7850       };
7851     } catch (Dali::DaliException e) {
7852       {
7853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7854       };
7855     } catch (...) {
7856       {
7857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7858       };
7859     }
7860   }
7861
7862   jresult = (void *)result;
7863   return jresult;
7864 }
7865
7866
7867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7868   void * jresult ;
7869   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7870   Dali::Vector4 *arg2 = 0 ;
7871   Dali::Vector4 result;
7872
7873   arg1 = (Dali::Vector4 *)jarg1;
7874   arg2 = (Dali::Vector4 *)jarg2;
7875   if (!arg2) {
7876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7877     return 0;
7878   }
7879   {
7880     try {
7881       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7882     } catch (std::out_of_range& e) {
7883       {
7884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7885       };
7886     } catch (std::exception& e) {
7887       {
7888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7889       };
7890     } catch (Dali::DaliException e) {
7891       {
7892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7893       };
7894     } catch (...) {
7895       {
7896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7897       };
7898     }
7899   }
7900
7901   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7902   return jresult;
7903 }
7904
7905
7906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7907   void * jresult ;
7908   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7909   float arg2 ;
7910   Dali::Vector4 result;
7911
7912   arg1 = (Dali::Vector4 *)jarg1;
7913   arg2 = (float)jarg2;
7914   {
7915     try {
7916       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7917     } catch (std::out_of_range& e) {
7918       {
7919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7920       };
7921     } catch (std::exception& e) {
7922       {
7923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7924       };
7925     } catch (Dali::DaliException e) {
7926       {
7927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7928       };
7929     } catch (...) {
7930       {
7931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7932       };
7933     }
7934   }
7935
7936   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7937   return jresult;
7938 }
7939
7940
7941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7942   void * jresult ;
7943   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7944   Dali::Vector4 *arg2 = 0 ;
7945   Dali::Vector4 *result = 0 ;
7946
7947   arg1 = (Dali::Vector4 *)jarg1;
7948   arg2 = (Dali::Vector4 *)jarg2;
7949   if (!arg2) {
7950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7951     return 0;
7952   }
7953   {
7954     try {
7955       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7956     } catch (std::out_of_range& e) {
7957       {
7958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7959       };
7960     } catch (std::exception& e) {
7961       {
7962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7963       };
7964     } catch (Dali::DaliException e) {
7965       {
7966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7967       };
7968     } catch (...) {
7969       {
7970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7971       };
7972     }
7973   }
7974
7975   jresult = (void *)result;
7976   return jresult;
7977 }
7978
7979
7980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7981   void * jresult ;
7982   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7983   float arg2 ;
7984   Dali::Vector4 *result = 0 ;
7985
7986   arg1 = (Dali::Vector4 *)jarg1;
7987   arg2 = (float)jarg2;
7988   {
7989     try {
7990       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7991     } catch (std::out_of_range& e) {
7992       {
7993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7994       };
7995     } catch (std::exception& e) {
7996       {
7997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7998       };
7999     } catch (Dali::DaliException e) {
8000       {
8001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8002       };
8003     } catch (...) {
8004       {
8005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8006       };
8007     }
8008   }
8009
8010   jresult = (void *)result;
8011   return jresult;
8012 }
8013
8014
8015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8016   void * jresult ;
8017   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8018   Dali::Vector4 result;
8019
8020   arg1 = (Dali::Vector4 *)jarg1;
8021   {
8022     try {
8023       result = ((Dali::Vector4 const *)arg1)->operator -();
8024     } catch (std::out_of_range& e) {
8025       {
8026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8027       };
8028     } catch (std::exception& e) {
8029       {
8030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8031       };
8032     } catch (Dali::DaliException e) {
8033       {
8034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8035       };
8036     } catch (...) {
8037       {
8038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8039       };
8040     }
8041   }
8042
8043   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8044   return jresult;
8045 }
8046
8047
8048 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8049   unsigned int jresult ;
8050   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8051   Dali::Vector4 *arg2 = 0 ;
8052   bool result;
8053
8054   arg1 = (Dali::Vector4 *)jarg1;
8055   arg2 = (Dali::Vector4 *)jarg2;
8056   if (!arg2) {
8057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8058     return 0;
8059   }
8060   {
8061     try {
8062       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8063     } catch (std::out_of_range& e) {
8064       {
8065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8066       };
8067     } catch (std::exception& e) {
8068       {
8069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8070       };
8071     } catch (Dali::DaliException e) {
8072       {
8073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8074       };
8075     } catch (...) {
8076       {
8077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8078       };
8079     }
8080   }
8081
8082   jresult = result;
8083   return jresult;
8084 }
8085
8086
8087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8088   unsigned int jresult ;
8089   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8090   Dali::Vector4 *arg2 = 0 ;
8091   bool result;
8092
8093   arg1 = (Dali::Vector4 *)jarg1;
8094   arg2 = (Dali::Vector4 *)jarg2;
8095   if (!arg2) {
8096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8097     return 0;
8098   }
8099   {
8100     try {
8101       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8102     } catch (std::out_of_range& e) {
8103       {
8104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8105       };
8106     } catch (std::exception& e) {
8107       {
8108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8109       };
8110     } catch (Dali::DaliException e) {
8111       {
8112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8113       };
8114     } catch (...) {
8115       {
8116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8117       };
8118     }
8119   }
8120
8121   jresult = result;
8122   return jresult;
8123 }
8124
8125
8126 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8127   float jresult ;
8128   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8129   unsigned int arg2 ;
8130   float *result = 0 ;
8131
8132   arg1 = (Dali::Vector4 *)jarg1;
8133   arg2 = (unsigned int)jarg2;
8134   {
8135     try {
8136       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8137     } catch (std::out_of_range& e) {
8138       {
8139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8140       };
8141     } catch (std::exception& e) {
8142       {
8143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8144       };
8145     } catch (Dali::DaliException e) {
8146       {
8147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8148       };
8149     } catch (...) {
8150       {
8151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8152       };
8153     }
8154   }
8155
8156   jresult = *result;
8157   return jresult;
8158 }
8159
8160
8161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8162   float jresult ;
8163   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8164   Dali::Vector3 *arg2 = 0 ;
8165   float result;
8166
8167   arg1 = (Dali::Vector4 *)jarg1;
8168   arg2 = (Dali::Vector3 *)jarg2;
8169   if (!arg2) {
8170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8171     return 0;
8172   }
8173   {
8174     try {
8175       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8176     } catch (std::out_of_range& e) {
8177       {
8178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8179       };
8180     } catch (std::exception& e) {
8181       {
8182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8183       };
8184     } catch (Dali::DaliException e) {
8185       {
8186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8187       };
8188     } catch (...) {
8189       {
8190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8191       };
8192     }
8193   }
8194
8195   jresult = result;
8196   return jresult;
8197 }
8198
8199
8200 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8201   float jresult ;
8202   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8203   Dali::Vector4 *arg2 = 0 ;
8204   float result;
8205
8206   arg1 = (Dali::Vector4 *)jarg1;
8207   arg2 = (Dali::Vector4 *)jarg2;
8208   if (!arg2) {
8209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8210     return 0;
8211   }
8212   {
8213     try {
8214       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8215     } catch (std::out_of_range& e) {
8216       {
8217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8218       };
8219     } catch (std::exception& e) {
8220       {
8221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8222       };
8223     } catch (Dali::DaliException e) {
8224       {
8225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8226       };
8227     } catch (...) {
8228       {
8229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8230       };
8231     }
8232   }
8233
8234   jresult = result;
8235   return jresult;
8236 }
8237
8238
8239 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8240   float jresult ;
8241   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8242   Dali::Vector4 *arg2 = 0 ;
8243   float result;
8244
8245   arg1 = (Dali::Vector4 *)jarg1;
8246   arg2 = (Dali::Vector4 *)jarg2;
8247   if (!arg2) {
8248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8249     return 0;
8250   }
8251   {
8252     try {
8253       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8254     } catch (std::out_of_range& e) {
8255       {
8256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8257       };
8258     } catch (std::exception& e) {
8259       {
8260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8261       };
8262     } catch (Dali::DaliException e) {
8263       {
8264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8265       };
8266     } catch (...) {
8267       {
8268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8269       };
8270     }
8271   }
8272
8273   jresult = result;
8274   return jresult;
8275 }
8276
8277
8278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8279   void * jresult ;
8280   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8281   Dali::Vector4 *arg2 = 0 ;
8282   Dali::Vector4 result;
8283
8284   arg1 = (Dali::Vector4 *)jarg1;
8285   arg2 = (Dali::Vector4 *)jarg2;
8286   if (!arg2) {
8287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8288     return 0;
8289   }
8290   {
8291     try {
8292       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8293     } catch (std::out_of_range& e) {
8294       {
8295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8296       };
8297     } catch (std::exception& e) {
8298       {
8299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8300       };
8301     } catch (Dali::DaliException e) {
8302       {
8303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8304       };
8305     } catch (...) {
8306       {
8307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8308       };
8309     }
8310   }
8311
8312   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8313   return jresult;
8314 }
8315
8316
8317 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8318   float jresult ;
8319   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8320   float result;
8321
8322   arg1 = (Dali::Vector4 *)jarg1;
8323   {
8324     try {
8325       result = (float)((Dali::Vector4 const *)arg1)->Length();
8326     } catch (std::out_of_range& e) {
8327       {
8328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8329       };
8330     } catch (std::exception& e) {
8331       {
8332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8333       };
8334     } catch (Dali::DaliException e) {
8335       {
8336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8337       };
8338     } catch (...) {
8339       {
8340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8341       };
8342     }
8343   }
8344
8345   jresult = result;
8346   return jresult;
8347 }
8348
8349
8350 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8351   float jresult ;
8352   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8353   float result;
8354
8355   arg1 = (Dali::Vector4 *)jarg1;
8356   {
8357     try {
8358       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8359     } catch (std::out_of_range& e) {
8360       {
8361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8362       };
8363     } catch (std::exception& e) {
8364       {
8365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8366       };
8367     } catch (Dali::DaliException e) {
8368       {
8369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8370       };
8371     } catch (...) {
8372       {
8373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8374       };
8375     }
8376   }
8377
8378   jresult = result;
8379   return jresult;
8380 }
8381
8382
8383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8384   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8385
8386   arg1 = (Dali::Vector4 *)jarg1;
8387   {
8388     try {
8389       (arg1)->Normalize();
8390     } catch (std::out_of_range& e) {
8391       {
8392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8393       };
8394     } catch (std::exception& e) {
8395       {
8396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8397       };
8398     } catch (Dali::DaliException e) {
8399       {
8400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8401       };
8402     } catch (...) {
8403       {
8404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8405       };
8406     }
8407   }
8408
8409 }
8410
8411
8412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8413   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8414   Dali::Vector4 *arg2 = 0 ;
8415   Dali::Vector4 *arg3 = 0 ;
8416
8417   arg1 = (Dali::Vector4 *)jarg1;
8418   arg2 = (Dali::Vector4 *)jarg2;
8419   if (!arg2) {
8420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8421     return ;
8422   }
8423   arg3 = (Dali::Vector4 *)jarg3;
8424   if (!arg3) {
8425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8426     return ;
8427   }
8428   {
8429     try {
8430       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8431     } catch (std::out_of_range& e) {
8432       {
8433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8434       };
8435     } catch (std::exception& e) {
8436       {
8437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8438       };
8439     } catch (Dali::DaliException e) {
8440       {
8441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8442       };
8443     } catch (...) {
8444       {
8445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8446       };
8447     }
8448   }
8449
8450 }
8451
8452
8453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8454   void * jresult ;
8455   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8456   float *result = 0 ;
8457
8458   arg1 = (Dali::Vector4 *)jarg1;
8459   {
8460     try {
8461       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8462     } catch (std::out_of_range& e) {
8463       {
8464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8465       };
8466     } catch (std::exception& e) {
8467       {
8468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8469       };
8470     } catch (Dali::DaliException e) {
8471       {
8472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8473       };
8474     } catch (...) {
8475       {
8476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8477       };
8478     }
8479   }
8480
8481   jresult = (void *)result;
8482   return jresult;
8483 }
8484
8485
8486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8487   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8488   float arg2 ;
8489
8490   arg1 = (Dali::Vector4 *)jarg1;
8491   arg2 = (float)jarg2;
8492   if (arg1) (arg1)->x = arg2;
8493 }
8494
8495
8496 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8497   float jresult ;
8498   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8499   float result;
8500
8501   arg1 = (Dali::Vector4 *)jarg1;
8502   result = (float) ((arg1)->x);
8503   jresult = result;
8504   return jresult;
8505 }
8506
8507
8508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8509   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8510   float arg2 ;
8511
8512   arg1 = (Dali::Vector4 *)jarg1;
8513   arg2 = (float)jarg2;
8514   if (arg1) (arg1)->r = arg2;
8515 }
8516
8517
8518 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8519   float jresult ;
8520   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8521   float result;
8522
8523   arg1 = (Dali::Vector4 *)jarg1;
8524   result = (float) ((arg1)->r);
8525   jresult = result;
8526   return jresult;
8527 }
8528
8529
8530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8531   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8532   float arg2 ;
8533
8534   arg1 = (Dali::Vector4 *)jarg1;
8535   arg2 = (float)jarg2;
8536   if (arg1) (arg1)->s = arg2;
8537 }
8538
8539
8540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8541   float jresult ;
8542   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8543   float result;
8544
8545   arg1 = (Dali::Vector4 *)jarg1;
8546   result = (float) ((arg1)->s);
8547   jresult = result;
8548   return jresult;
8549 }
8550
8551
8552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8553   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8554   float arg2 ;
8555
8556   arg1 = (Dali::Vector4 *)jarg1;
8557   arg2 = (float)jarg2;
8558   if (arg1) (arg1)->y = arg2;
8559 }
8560
8561
8562 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8563   float jresult ;
8564   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8565   float result;
8566
8567   arg1 = (Dali::Vector4 *)jarg1;
8568   result = (float) ((arg1)->y);
8569   jresult = result;
8570   return jresult;
8571 }
8572
8573
8574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8575   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8576   float arg2 ;
8577
8578   arg1 = (Dali::Vector4 *)jarg1;
8579   arg2 = (float)jarg2;
8580   if (arg1) (arg1)->g = arg2;
8581 }
8582
8583
8584 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8585   float jresult ;
8586   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8587   float result;
8588
8589   arg1 = (Dali::Vector4 *)jarg1;
8590   result = (float) ((arg1)->g);
8591   jresult = result;
8592   return jresult;
8593 }
8594
8595
8596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8597   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8598   float arg2 ;
8599
8600   arg1 = (Dali::Vector4 *)jarg1;
8601   arg2 = (float)jarg2;
8602   if (arg1) (arg1)->t = arg2;
8603 }
8604
8605
8606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8607   float jresult ;
8608   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8609   float result;
8610
8611   arg1 = (Dali::Vector4 *)jarg1;
8612   result = (float) ((arg1)->t);
8613   jresult = result;
8614   return jresult;
8615 }
8616
8617
8618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8619   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8620   float arg2 ;
8621
8622   arg1 = (Dali::Vector4 *)jarg1;
8623   arg2 = (float)jarg2;
8624   if (arg1) (arg1)->z = arg2;
8625 }
8626
8627
8628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8629   float jresult ;
8630   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8631   float result;
8632
8633   arg1 = (Dali::Vector4 *)jarg1;
8634   result = (float) ((arg1)->z);
8635   jresult = result;
8636   return jresult;
8637 }
8638
8639
8640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8641   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8642   float arg2 ;
8643
8644   arg1 = (Dali::Vector4 *)jarg1;
8645   arg2 = (float)jarg2;
8646   if (arg1) (arg1)->b = arg2;
8647 }
8648
8649
8650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8651   float jresult ;
8652   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8653   float result;
8654
8655   arg1 = (Dali::Vector4 *)jarg1;
8656   result = (float) ((arg1)->b);
8657   jresult = result;
8658   return jresult;
8659 }
8660
8661
8662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8663   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8664   float arg2 ;
8665
8666   arg1 = (Dali::Vector4 *)jarg1;
8667   arg2 = (float)jarg2;
8668   if (arg1) (arg1)->p = arg2;
8669 }
8670
8671
8672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8673   float jresult ;
8674   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8675   float result;
8676
8677   arg1 = (Dali::Vector4 *)jarg1;
8678   result = (float) ((arg1)->p);
8679   jresult = result;
8680   return jresult;
8681 }
8682
8683
8684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8685   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8686   float arg2 ;
8687
8688   arg1 = (Dali::Vector4 *)jarg1;
8689   arg2 = (float)jarg2;
8690   if (arg1) (arg1)->w = arg2;
8691 }
8692
8693
8694 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8695   float jresult ;
8696   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8697   float result;
8698
8699   arg1 = (Dali::Vector4 *)jarg1;
8700   result = (float) ((arg1)->w);
8701   jresult = result;
8702   return jresult;
8703 }
8704
8705
8706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8707   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8708   float arg2 ;
8709
8710   arg1 = (Dali::Vector4 *)jarg1;
8711   arg2 = (float)jarg2;
8712   if (arg1) (arg1)->a = arg2;
8713 }
8714
8715
8716 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8717   float jresult ;
8718   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8719   float result;
8720
8721   arg1 = (Dali::Vector4 *)jarg1;
8722   result = (float) ((arg1)->a);
8723   jresult = result;
8724   return jresult;
8725 }
8726
8727
8728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8729   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8730   float arg2 ;
8731
8732   arg1 = (Dali::Vector4 *)jarg1;
8733   arg2 = (float)jarg2;
8734   if (arg1) (arg1)->q = arg2;
8735 }
8736
8737
8738 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8739   float jresult ;
8740   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8741   float result;
8742
8743   arg1 = (Dali::Vector4 *)jarg1;
8744   result = (float) ((arg1)->q);
8745   jresult = result;
8746   return jresult;
8747 }
8748
8749
8750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8751   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8752
8753   arg1 = (Dali::Vector4 *)jarg1;
8754   {
8755     try {
8756       delete arg1;
8757     } catch (std::out_of_range& e) {
8758       {
8759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8760       };
8761     } catch (std::exception& e) {
8762       {
8763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8764       };
8765     } catch (Dali::DaliException e) {
8766       {
8767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8768       };
8769     } catch (...) {
8770       {
8771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8772       };
8773     }
8774   }
8775
8776 }
8777
8778
8779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8780   void * jresult ;
8781   Dali::Vector4 *arg1 = 0 ;
8782   Dali::Vector4 *arg2 = 0 ;
8783   Dali::Vector4 result;
8784
8785   arg1 = (Dali::Vector4 *)jarg1;
8786   if (!arg1) {
8787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8788     return 0;
8789   }
8790   arg2 = (Dali::Vector4 *)jarg2;
8791   if (!arg2) {
8792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8793     return 0;
8794   }
8795   {
8796     try {
8797       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8798     } catch (std::out_of_range& e) {
8799       {
8800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8801       };
8802     } catch (std::exception& e) {
8803       {
8804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8805       };
8806     } catch (Dali::DaliException e) {
8807       {
8808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8809       };
8810     } catch (...) {
8811       {
8812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8813       };
8814     }
8815   }
8816
8817   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8818   return jresult;
8819 }
8820
8821
8822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8823   void * jresult ;
8824   Dali::Vector4 *arg1 = 0 ;
8825   Dali::Vector4 *arg2 = 0 ;
8826   Dali::Vector4 result;
8827
8828   arg1 = (Dali::Vector4 *)jarg1;
8829   if (!arg1) {
8830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8831     return 0;
8832   }
8833   arg2 = (Dali::Vector4 *)jarg2;
8834   if (!arg2) {
8835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8836     return 0;
8837   }
8838   {
8839     try {
8840       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8841     } catch (std::out_of_range& e) {
8842       {
8843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8844       };
8845     } catch (std::exception& e) {
8846       {
8847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8848       };
8849     } catch (Dali::DaliException e) {
8850       {
8851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8852       };
8853     } catch (...) {
8854       {
8855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8856       };
8857     }
8858   }
8859
8860   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8861   return jresult;
8862 }
8863
8864
8865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8866   void * jresult ;
8867   Dali::Vector4 *arg1 = 0 ;
8868   float *arg2 = 0 ;
8869   float *arg3 = 0 ;
8870   float temp2 ;
8871   float temp3 ;
8872   Dali::Vector4 result;
8873
8874   arg1 = (Dali::Vector4 *)jarg1;
8875   if (!arg1) {
8876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8877     return 0;
8878   }
8879   temp2 = (float)jarg2;
8880   arg2 = &temp2;
8881   temp3 = (float)jarg3;
8882   arg3 = &temp3;
8883   {
8884     try {
8885       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8886     } catch (std::out_of_range& e) {
8887       {
8888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8889       };
8890     } catch (std::exception& e) {
8891       {
8892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8893       };
8894     } catch (Dali::DaliException e) {
8895       {
8896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8897       };
8898     } catch (...) {
8899       {
8900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8901       };
8902     }
8903   }
8904
8905   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8906   return jresult;
8907 }
8908
8909
8910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8911   void * jresult ;
8912   Dali::Uint16Pair *result = 0 ;
8913
8914   {
8915     try {
8916       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8917     } catch (std::out_of_range& e) {
8918       {
8919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8920       };
8921     } catch (std::exception& e) {
8922       {
8923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8924       };
8925     } catch (Dali::DaliException e) {
8926       {
8927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8928       };
8929     } catch (...) {
8930       {
8931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8932       };
8933     }
8934   }
8935
8936   jresult = (void *)result;
8937   return jresult;
8938 }
8939
8940
8941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8942   void * jresult ;
8943   uint32_t arg1 ;
8944   uint32_t arg2 ;
8945   Dali::Uint16Pair *result = 0 ;
8946
8947   arg1 = (uint32_t)jarg1;
8948   arg2 = (uint32_t)jarg2;
8949   {
8950     try {
8951       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8952     } catch (std::out_of_range& e) {
8953       {
8954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8955       };
8956     } catch (std::exception& e) {
8957       {
8958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8959       };
8960     } catch (Dali::DaliException e) {
8961       {
8962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8963       };
8964     } catch (...) {
8965       {
8966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8967       };
8968     }
8969   }
8970
8971   jresult = (void *)result;
8972   return jresult;
8973 }
8974
8975
8976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8977   void * jresult ;
8978   Dali::Uint16Pair *arg1 = 0 ;
8979   Dali::Uint16Pair *result = 0 ;
8980
8981   arg1 = (Dali::Uint16Pair *)jarg1;
8982   if (!arg1) {
8983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8984     return 0;
8985   }
8986   {
8987     try {
8988       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8989     } catch (std::out_of_range& e) {
8990       {
8991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8992       };
8993     } catch (std::exception& e) {
8994       {
8995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8996       };
8997     } catch (Dali::DaliException e) {
8998       {
8999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9000       };
9001     } catch (...) {
9002       {
9003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9004       };
9005     }
9006   }
9007
9008   jresult = (void *)result;
9009   return jresult;
9010 }
9011
9012
9013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9014   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9015   uint16_t arg2 ;
9016
9017   arg1 = (Dali::Uint16Pair *)jarg1;
9018   arg2 = (uint16_t)jarg2;
9019   {
9020     try {
9021       (arg1)->SetWidth(arg2);
9022     } catch (std::out_of_range& e) {
9023       {
9024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9025       };
9026     } catch (std::exception& e) {
9027       {
9028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9029       };
9030     } catch (Dali::DaliException e) {
9031       {
9032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9033       };
9034     } catch (...) {
9035       {
9036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9037       };
9038     }
9039   }
9040
9041 }
9042
9043
9044 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9045   unsigned short jresult ;
9046   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9047   uint16_t result;
9048
9049   arg1 = (Dali::Uint16Pair *)jarg1;
9050   {
9051     try {
9052       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9053     } catch (std::out_of_range& e) {
9054       {
9055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9056       };
9057     } catch (std::exception& e) {
9058       {
9059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9060       };
9061     } catch (Dali::DaliException e) {
9062       {
9063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9064       };
9065     } catch (...) {
9066       {
9067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9068       };
9069     }
9070   }
9071
9072   jresult = result;
9073   return jresult;
9074 }
9075
9076
9077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9078   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9079   uint16_t arg2 ;
9080
9081   arg1 = (Dali::Uint16Pair *)jarg1;
9082   arg2 = (uint16_t)jarg2;
9083   {
9084     try {
9085       (arg1)->SetHeight(arg2);
9086     } catch (std::out_of_range& e) {
9087       {
9088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9089       };
9090     } catch (std::exception& e) {
9091       {
9092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9093       };
9094     } catch (Dali::DaliException e) {
9095       {
9096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9097       };
9098     } catch (...) {
9099       {
9100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9101       };
9102     }
9103   }
9104
9105 }
9106
9107
9108 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9109   unsigned short jresult ;
9110   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9111   uint16_t result;
9112
9113   arg1 = (Dali::Uint16Pair *)jarg1;
9114   {
9115     try {
9116       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9117     } catch (std::out_of_range& e) {
9118       {
9119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9120       };
9121     } catch (std::exception& e) {
9122       {
9123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9124       };
9125     } catch (Dali::DaliException e) {
9126       {
9127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9128       };
9129     } catch (...) {
9130       {
9131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9132       };
9133     }
9134   }
9135
9136   jresult = result;
9137   return jresult;
9138 }
9139
9140
9141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9142   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9143   uint16_t arg2 ;
9144
9145   arg1 = (Dali::Uint16Pair *)jarg1;
9146   arg2 = (uint16_t)jarg2;
9147   {
9148     try {
9149       (arg1)->SetX(arg2);
9150     } catch (std::out_of_range& e) {
9151       {
9152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9153       };
9154     } catch (std::exception& e) {
9155       {
9156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9157       };
9158     } catch (Dali::DaliException e) {
9159       {
9160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9161       };
9162     } catch (...) {
9163       {
9164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9165       };
9166     }
9167   }
9168
9169 }
9170
9171
9172 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9173   unsigned short jresult ;
9174   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9175   uint16_t result;
9176
9177   arg1 = (Dali::Uint16Pair *)jarg1;
9178   {
9179     try {
9180       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9181     } catch (std::out_of_range& e) {
9182       {
9183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9184       };
9185     } catch (std::exception& e) {
9186       {
9187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9188       };
9189     } catch (Dali::DaliException e) {
9190       {
9191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9192       };
9193     } catch (...) {
9194       {
9195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9196       };
9197     }
9198   }
9199
9200   jresult = result;
9201   return jresult;
9202 }
9203
9204
9205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9206   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9207   uint16_t arg2 ;
9208
9209   arg1 = (Dali::Uint16Pair *)jarg1;
9210   arg2 = (uint16_t)jarg2;
9211   {
9212     try {
9213       (arg1)->SetY(arg2);
9214     } catch (std::out_of_range& e) {
9215       {
9216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9217       };
9218     } catch (std::exception& e) {
9219       {
9220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9221       };
9222     } catch (Dali::DaliException e) {
9223       {
9224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9225       };
9226     } catch (...) {
9227       {
9228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9229       };
9230     }
9231   }
9232
9233 }
9234
9235
9236 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9237   unsigned short jresult ;
9238   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9239   uint16_t result;
9240
9241   arg1 = (Dali::Uint16Pair *)jarg1;
9242   {
9243     try {
9244       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9245     } catch (std::out_of_range& e) {
9246       {
9247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9248       };
9249     } catch (std::exception& e) {
9250       {
9251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9252       };
9253     } catch (Dali::DaliException e) {
9254       {
9255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9256       };
9257     } catch (...) {
9258       {
9259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9260       };
9261     }
9262   }
9263
9264   jresult = result;
9265   return jresult;
9266 }
9267
9268
9269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9270   void * jresult ;
9271   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9272   Dali::Uint16Pair *arg2 = 0 ;
9273   Dali::Uint16Pair *result = 0 ;
9274
9275   arg1 = (Dali::Uint16Pair *)jarg1;
9276   arg2 = (Dali::Uint16Pair *)jarg2;
9277   if (!arg2) {
9278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9279     return 0;
9280   }
9281   {
9282     try {
9283       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9284     } catch (std::out_of_range& e) {
9285       {
9286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9287       };
9288     } catch (std::exception& e) {
9289       {
9290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9291       };
9292     } catch (Dali::DaliException e) {
9293       {
9294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9295       };
9296     } catch (...) {
9297       {
9298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9299       };
9300     }
9301   }
9302
9303   jresult = (void *)result;
9304   return jresult;
9305 }
9306
9307
9308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9309   unsigned int jresult ;
9310   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9311   Dali::Uint16Pair *arg2 = 0 ;
9312   bool result;
9313
9314   arg1 = (Dali::Uint16Pair *)jarg1;
9315   arg2 = (Dali::Uint16Pair *)jarg2;
9316   if (!arg2) {
9317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9318     return 0;
9319   }
9320   {
9321     try {
9322       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9323     } catch (std::out_of_range& e) {
9324       {
9325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9326       };
9327     } catch (std::exception& e) {
9328       {
9329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9330       };
9331     } catch (Dali::DaliException e) {
9332       {
9333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9334       };
9335     } catch (...) {
9336       {
9337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9338       };
9339     }
9340   }
9341
9342   jresult = result;
9343   return jresult;
9344 }
9345
9346
9347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9348   unsigned int jresult ;
9349   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9350   Dali::Uint16Pair *arg2 = 0 ;
9351   bool result;
9352
9353   arg1 = (Dali::Uint16Pair *)jarg1;
9354   arg2 = (Dali::Uint16Pair *)jarg2;
9355   if (!arg2) {
9356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9357     return 0;
9358   }
9359   {
9360     try {
9361       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9362     } catch (std::out_of_range& e) {
9363       {
9364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9365       };
9366     } catch (std::exception& e) {
9367       {
9368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9369       };
9370     } catch (Dali::DaliException e) {
9371       {
9372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9373       };
9374     } catch (...) {
9375       {
9376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9377       };
9378     }
9379   }
9380
9381   jresult = result;
9382   return jresult;
9383 }
9384
9385
9386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9387   unsigned int jresult ;
9388   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9389   Dali::Uint16Pair *arg2 = 0 ;
9390   bool result;
9391
9392   arg1 = (Dali::Uint16Pair *)jarg1;
9393   arg2 = (Dali::Uint16Pair *)jarg2;
9394   if (!arg2) {
9395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9396     return 0;
9397   }
9398   {
9399     try {
9400       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9401     } catch (std::out_of_range& e) {
9402       {
9403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9404       };
9405     } catch (std::exception& e) {
9406       {
9407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9408       };
9409     } catch (Dali::DaliException e) {
9410       {
9411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9412       };
9413     } catch (...) {
9414       {
9415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9416       };
9417     }
9418   }
9419
9420   jresult = result;
9421   return jresult;
9422 }
9423
9424
9425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9426   unsigned int jresult ;
9427   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9428   Dali::Uint16Pair *arg2 = 0 ;
9429   bool result;
9430
9431   arg1 = (Dali::Uint16Pair *)jarg1;
9432   arg2 = (Dali::Uint16Pair *)jarg2;
9433   if (!arg2) {
9434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9435     return 0;
9436   }
9437   {
9438     try {
9439       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9440     } catch (std::out_of_range& e) {
9441       {
9442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9443       };
9444     } catch (std::exception& e) {
9445       {
9446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9447       };
9448     } catch (Dali::DaliException e) {
9449       {
9450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9451       };
9452     } catch (...) {
9453       {
9454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9455       };
9456     }
9457   }
9458
9459   jresult = result;
9460   return jresult;
9461 }
9462
9463
9464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9465   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9466
9467   arg1 = (Dali::Uint16Pair *)jarg1;
9468   {
9469     try {
9470       delete arg1;
9471     } catch (std::out_of_range& e) {
9472       {
9473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9474       };
9475     } catch (std::exception& e) {
9476       {
9477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9478       };
9479     } catch (Dali::DaliException e) {
9480       {
9481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9482       };
9483     } catch (...) {
9484       {
9485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9486       };
9487     }
9488   }
9489
9490 }
9491
9492
9493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9494   void * jresult ;
9495   Dali::Degree *result = 0 ;
9496
9497   {
9498     try {
9499       result = (Dali::Degree *)new Dali::Degree();
9500     } catch (std::out_of_range& e) {
9501       {
9502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9503       };
9504     } catch (std::exception& e) {
9505       {
9506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9507       };
9508     } catch (Dali::DaliException e) {
9509       {
9510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9511       };
9512     } catch (...) {
9513       {
9514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9515       };
9516     }
9517   }
9518
9519   jresult = (void *)result;
9520   return jresult;
9521 }
9522
9523
9524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9525   void * jresult ;
9526   float arg1 ;
9527   Dali::Degree *result = 0 ;
9528
9529   arg1 = (float)jarg1;
9530   {
9531     try {
9532       result = (Dali::Degree *)new Dali::Degree(arg1);
9533     } catch (std::out_of_range& e) {
9534       {
9535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9536       };
9537     } catch (std::exception& e) {
9538       {
9539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9540       };
9541     } catch (Dali::DaliException e) {
9542       {
9543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9544       };
9545     } catch (...) {
9546       {
9547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9548       };
9549     }
9550   }
9551
9552   jresult = (void *)result;
9553   return jresult;
9554 }
9555
9556
9557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9558   void * jresult ;
9559   Dali::Radian arg1 ;
9560   Dali::Radian *argp1 ;
9561   Dali::Degree *result = 0 ;
9562
9563   argp1 = (Dali::Radian *)jarg1;
9564   if (!argp1) {
9565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9566     return 0;
9567   }
9568   arg1 = *argp1;
9569   {
9570     try {
9571       result = (Dali::Degree *)new Dali::Degree(arg1);
9572     } catch (std::out_of_range& e) {
9573       {
9574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9575       };
9576     } catch (std::exception& e) {
9577       {
9578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9579       };
9580     } catch (Dali::DaliException e) {
9581       {
9582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9583       };
9584     } catch (...) {
9585       {
9586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9587       };
9588     }
9589   }
9590
9591   jresult = (void *)result;
9592   return jresult;
9593 }
9594
9595
9596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9597   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9598   float arg2 ;
9599
9600   arg1 = (Dali::Degree *)jarg1;
9601   arg2 = (float)jarg2;
9602   if (arg1) (arg1)->degree = arg2;
9603 }
9604
9605
9606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9607   float jresult ;
9608   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9609   float result;
9610
9611   arg1 = (Dali::Degree *)jarg1;
9612   result = (float) ((arg1)->degree);
9613   jresult = result;
9614   return jresult;
9615 }
9616
9617
9618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9619   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9620
9621   arg1 = (Dali::Degree *)jarg1;
9622   {
9623     try {
9624       delete arg1;
9625     } catch (std::out_of_range& e) {
9626       {
9627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9628       };
9629     } catch (std::exception& e) {
9630       {
9631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9632       };
9633     } catch (Dali::DaliException e) {
9634       {
9635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9636       };
9637     } catch (...) {
9638       {
9639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9640       };
9641     }
9642   }
9643
9644 }
9645
9646
9647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9648   void * jresult ;
9649   Dali::Radian *result = 0 ;
9650
9651   result = (Dali::Radian *)&Dali::ANGLE_360;
9652   jresult = (void *)result;
9653   return jresult;
9654 }
9655
9656
9657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9658   void * jresult ;
9659   Dali::Radian *result = 0 ;
9660
9661   result = (Dali::Radian *)&Dali::ANGLE_315;
9662   jresult = (void *)result;
9663   return jresult;
9664 }
9665
9666
9667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9668   void * jresult ;
9669   Dali::Radian *result = 0 ;
9670
9671   result = (Dali::Radian *)&Dali::ANGLE_270;
9672   jresult = (void *)result;
9673   return jresult;
9674 }
9675
9676
9677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9678   void * jresult ;
9679   Dali::Radian *result = 0 ;
9680
9681   result = (Dali::Radian *)&Dali::ANGLE_225;
9682   jresult = (void *)result;
9683   return jresult;
9684 }
9685
9686
9687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9688   void * jresult ;
9689   Dali::Radian *result = 0 ;
9690
9691   result = (Dali::Radian *)&Dali::ANGLE_180;
9692   jresult = (void *)result;
9693   return jresult;
9694 }
9695
9696
9697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9698   void * jresult ;
9699   Dali::Radian *result = 0 ;
9700
9701   result = (Dali::Radian *)&Dali::ANGLE_135;
9702   jresult = (void *)result;
9703   return jresult;
9704 }
9705
9706
9707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9708   void * jresult ;
9709   Dali::Radian *result = 0 ;
9710
9711   result = (Dali::Radian *)&Dali::ANGLE_120;
9712   jresult = (void *)result;
9713   return jresult;
9714 }
9715
9716
9717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9718   void * jresult ;
9719   Dali::Radian *result = 0 ;
9720
9721   result = (Dali::Radian *)&Dali::ANGLE_90;
9722   jresult = (void *)result;
9723   return jresult;
9724 }
9725
9726
9727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9728   void * jresult ;
9729   Dali::Radian *result = 0 ;
9730
9731   result = (Dali::Radian *)&Dali::ANGLE_60;
9732   jresult = (void *)result;
9733   return jresult;
9734 }
9735
9736
9737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9738   void * jresult ;
9739   Dali::Radian *result = 0 ;
9740
9741   result = (Dali::Radian *)&Dali::ANGLE_45;
9742   jresult = (void *)result;
9743   return jresult;
9744 }
9745
9746
9747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9748   void * jresult ;
9749   Dali::Radian *result = 0 ;
9750
9751   result = (Dali::Radian *)&Dali::ANGLE_30;
9752   jresult = (void *)result;
9753   return jresult;
9754 }
9755
9756
9757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9758   void * jresult ;
9759   Dali::Radian *result = 0 ;
9760
9761   result = (Dali::Radian *)&Dali::ANGLE_0;
9762   jresult = (void *)result;
9763   return jresult;
9764 }
9765
9766
9767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9768   unsigned int jresult ;
9769   Dali::Degree *arg1 = 0 ;
9770   Dali::Degree *arg2 = 0 ;
9771   bool result;
9772
9773   arg1 = (Dali::Degree *)jarg1;
9774   if (!arg1) {
9775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9776     return 0;
9777   }
9778   arg2 = (Dali::Degree *)jarg2;
9779   if (!arg2) {
9780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9781     return 0;
9782   }
9783   {
9784     try {
9785       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9786     } catch (std::out_of_range& e) {
9787       {
9788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9789       };
9790     } catch (std::exception& e) {
9791       {
9792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9793       };
9794     } catch (Dali::DaliException e) {
9795       {
9796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9797       };
9798     } catch (...) {
9799       {
9800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9801       };
9802     }
9803   }
9804
9805   jresult = result;
9806   return jresult;
9807 }
9808
9809
9810 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9811   unsigned int jresult ;
9812   Dali::Degree *arg1 = 0 ;
9813   Dali::Degree *arg2 = 0 ;
9814   bool result;
9815
9816   arg1 = (Dali::Degree *)jarg1;
9817   if (!arg1) {
9818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9819     return 0;
9820   }
9821   arg2 = (Dali::Degree *)jarg2;
9822   if (!arg2) {
9823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9824     return 0;
9825   }
9826   {
9827     try {
9828       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9829     } catch (std::out_of_range& e) {
9830       {
9831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9832       };
9833     } catch (std::exception& e) {
9834       {
9835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9836       };
9837     } catch (Dali::DaliException e) {
9838       {
9839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9840       };
9841     } catch (...) {
9842       {
9843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9844       };
9845     }
9846   }
9847
9848   jresult = result;
9849   return jresult;
9850 }
9851
9852
9853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9854   void * jresult ;
9855   Dali::Degree arg1 ;
9856   float arg2 ;
9857   float arg3 ;
9858   Dali::Degree *argp1 ;
9859   Dali::Degree result;
9860
9861   argp1 = (Dali::Degree *)jarg1;
9862   if (!argp1) {
9863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9864     return 0;
9865   }
9866   arg1 = *argp1;
9867   arg2 = (float)jarg2;
9868   arg3 = (float)jarg3;
9869   {
9870     try {
9871       result = Dali::Clamp(arg1,arg2,arg3);
9872     } catch (std::out_of_range& e) {
9873       {
9874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9875       };
9876     } catch (std::exception& e) {
9877       {
9878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9879       };
9880     } catch (Dali::DaliException e) {
9881       {
9882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9883       };
9884     } catch (...) {
9885       {
9886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9887       };
9888     }
9889   }
9890
9891   jresult = new Dali::Degree((const Dali::Degree &)result);
9892   return jresult;
9893 }
9894
9895
9896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9897   void * jresult ;
9898   Dali::Radian *result = 0 ;
9899
9900   {
9901     try {
9902       result = (Dali::Radian *)new Dali::Radian();
9903     } catch (std::out_of_range& e) {
9904       {
9905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9906       };
9907     } catch (std::exception& e) {
9908       {
9909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9910       };
9911     } catch (Dali::DaliException e) {
9912       {
9913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9914       };
9915     } catch (...) {
9916       {
9917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9918       };
9919     }
9920   }
9921
9922   jresult = (void *)result;
9923   return jresult;
9924 }
9925
9926
9927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9928   void * jresult ;
9929   float arg1 ;
9930   Dali::Radian *result = 0 ;
9931
9932   arg1 = (float)jarg1;
9933   {
9934     try {
9935       result = (Dali::Radian *)new Dali::Radian(arg1);
9936     } catch (std::out_of_range& e) {
9937       {
9938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9939       };
9940     } catch (std::exception& e) {
9941       {
9942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9943       };
9944     } catch (Dali::DaliException e) {
9945       {
9946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9947       };
9948     } catch (...) {
9949       {
9950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9951       };
9952     }
9953   }
9954
9955   jresult = (void *)result;
9956   return jresult;
9957 }
9958
9959
9960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9961   void * jresult ;
9962   Dali::Degree arg1 ;
9963   Dali::Degree *argp1 ;
9964   Dali::Radian *result = 0 ;
9965
9966   argp1 = (Dali::Degree *)jarg1;
9967   if (!argp1) {
9968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9969     return 0;
9970   }
9971   arg1 = *argp1;
9972   {
9973     try {
9974       result = (Dali::Radian *)new Dali::Radian(arg1);
9975     } catch (std::out_of_range& e) {
9976       {
9977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9978       };
9979     } catch (std::exception& e) {
9980       {
9981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9982       };
9983     } catch (Dali::DaliException e) {
9984       {
9985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9986       };
9987     } catch (...) {
9988       {
9989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9990       };
9991     }
9992   }
9993
9994   jresult = (void *)result;
9995   return jresult;
9996 }
9997
9998
9999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10000   void * jresult ;
10001   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10002   float arg2 ;
10003   Dali::Radian *result = 0 ;
10004
10005   arg1 = (Dali::Radian *)jarg1;
10006   arg2 = (float)jarg2;
10007   {
10008     try {
10009       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10010     } catch (std::out_of_range& e) {
10011       {
10012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10013       };
10014     } catch (std::exception& e) {
10015       {
10016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10017       };
10018     } catch (Dali::DaliException e) {
10019       {
10020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10021       };
10022     } catch (...) {
10023       {
10024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10025       };
10026     }
10027   }
10028
10029   jresult = (void *)result;
10030   return jresult;
10031 }
10032
10033
10034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10035   void * jresult ;
10036   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10037   Dali::Degree arg2 ;
10038   Dali::Degree *argp2 ;
10039   Dali::Radian *result = 0 ;
10040
10041   arg1 = (Dali::Radian *)jarg1;
10042   argp2 = (Dali::Degree *)jarg2;
10043   if (!argp2) {
10044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10045     return 0;
10046   }
10047   arg2 = *argp2;
10048   {
10049     try {
10050       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10051     } catch (std::out_of_range& e) {
10052       {
10053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10054       };
10055     } catch (std::exception& e) {
10056       {
10057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10058       };
10059     } catch (Dali::DaliException e) {
10060       {
10061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10062       };
10063     } catch (...) {
10064       {
10065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10066       };
10067     }
10068   }
10069
10070   jresult = (void *)result;
10071   return jresult;
10072 }
10073
10074
10075 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10076   float jresult ;
10077   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10078   float result;
10079
10080   arg1 = (Dali::Radian *)jarg1;
10081   {
10082     try {
10083       result = (float)((Dali::Radian const *)arg1)->operator float();
10084     } catch (std::out_of_range& e) {
10085       {
10086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10087       };
10088     } catch (std::exception& e) {
10089       {
10090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10091       };
10092     } catch (Dali::DaliException e) {
10093       {
10094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10095       };
10096     } catch (...) {
10097       {
10098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10099       };
10100     }
10101   }
10102
10103   jresult = result;
10104   return jresult;
10105 }
10106
10107
10108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10109   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10110   float arg2 ;
10111
10112   arg1 = (Dali::Radian *)jarg1;
10113   arg2 = (float)jarg2;
10114   if (arg1) (arg1)->radian = arg2;
10115 }
10116
10117
10118 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10119   float jresult ;
10120   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10121   float result;
10122
10123   arg1 = (Dali::Radian *)jarg1;
10124   result = (float) ((arg1)->radian);
10125   jresult = result;
10126   return jresult;
10127 }
10128
10129
10130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10131   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10132
10133   arg1 = (Dali::Radian *)jarg1;
10134   {
10135     try {
10136       delete arg1;
10137     } catch (std::out_of_range& e) {
10138       {
10139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10140       };
10141     } catch (std::exception& e) {
10142       {
10143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10144       };
10145     } catch (Dali::DaliException e) {
10146       {
10147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10148       };
10149     } catch (...) {
10150       {
10151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10152       };
10153     }
10154   }
10155
10156 }
10157
10158
10159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10160   unsigned int jresult ;
10161   Dali::Radian arg1 ;
10162   Dali::Radian arg2 ;
10163   Dali::Radian *argp1 ;
10164   Dali::Radian *argp2 ;
10165   bool result;
10166
10167   argp1 = (Dali::Radian *)jarg1;
10168   if (!argp1) {
10169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10170     return 0;
10171   }
10172   arg1 = *argp1;
10173   argp2 = (Dali::Radian *)jarg2;
10174   if (!argp2) {
10175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10176     return 0;
10177   }
10178   arg2 = *argp2;
10179   {
10180     try {
10181       result = (bool)Dali::operator ==(arg1,arg2);
10182     } catch (std::out_of_range& e) {
10183       {
10184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10185       };
10186     } catch (std::exception& e) {
10187       {
10188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10189       };
10190     } catch (Dali::DaliException e) {
10191       {
10192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10193       };
10194     } catch (...) {
10195       {
10196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10197       };
10198     }
10199   }
10200
10201   jresult = result;
10202   return jresult;
10203 }
10204
10205
10206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10207   unsigned int jresult ;
10208   Dali::Radian arg1 ;
10209   Dali::Radian arg2 ;
10210   Dali::Radian *argp1 ;
10211   Dali::Radian *argp2 ;
10212   bool result;
10213
10214   argp1 = (Dali::Radian *)jarg1;
10215   if (!argp1) {
10216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10217     return 0;
10218   }
10219   arg1 = *argp1;
10220   argp2 = (Dali::Radian *)jarg2;
10221   if (!argp2) {
10222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10223     return 0;
10224   }
10225   arg2 = *argp2;
10226   {
10227     try {
10228       result = (bool)Dali::operator !=(arg1,arg2);
10229     } catch (std::out_of_range& e) {
10230       {
10231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10232       };
10233     } catch (std::exception& e) {
10234       {
10235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10236       };
10237     } catch (Dali::DaliException e) {
10238       {
10239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10240       };
10241     } catch (...) {
10242       {
10243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10244       };
10245     }
10246   }
10247
10248   jresult = result;
10249   return jresult;
10250 }
10251
10252
10253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10254   unsigned int jresult ;
10255   Dali::Radian arg1 ;
10256   Dali::Degree arg2 ;
10257   Dali::Radian *argp1 ;
10258   Dali::Degree *argp2 ;
10259   bool result;
10260
10261   argp1 = (Dali::Radian *)jarg1;
10262   if (!argp1) {
10263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10264     return 0;
10265   }
10266   arg1 = *argp1;
10267   argp2 = (Dali::Degree *)jarg2;
10268   if (!argp2) {
10269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10270     return 0;
10271   }
10272   arg2 = *argp2;
10273   {
10274     try {
10275       result = (bool)Dali::operator ==(arg1,arg2);
10276     } catch (std::out_of_range& e) {
10277       {
10278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10279       };
10280     } catch (std::exception& e) {
10281       {
10282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10283       };
10284     } catch (Dali::DaliException e) {
10285       {
10286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10287       };
10288     } catch (...) {
10289       {
10290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10291       };
10292     }
10293   }
10294
10295   jresult = result;
10296   return jresult;
10297 }
10298
10299
10300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10301   unsigned int jresult ;
10302   Dali::Radian arg1 ;
10303   Dali::Degree arg2 ;
10304   Dali::Radian *argp1 ;
10305   Dali::Degree *argp2 ;
10306   bool result;
10307
10308   argp1 = (Dali::Radian *)jarg1;
10309   if (!argp1) {
10310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10311     return 0;
10312   }
10313   arg1 = *argp1;
10314   argp2 = (Dali::Degree *)jarg2;
10315   if (!argp2) {
10316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10317     return 0;
10318   }
10319   arg2 = *argp2;
10320   {
10321     try {
10322       result = (bool)Dali::operator !=(arg1,arg2);
10323     } catch (std::out_of_range& e) {
10324       {
10325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10326       };
10327     } catch (std::exception& e) {
10328       {
10329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10330       };
10331     } catch (Dali::DaliException e) {
10332       {
10333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10334       };
10335     } catch (...) {
10336       {
10337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10338       };
10339     }
10340   }
10341
10342   jresult = result;
10343   return jresult;
10344 }
10345
10346
10347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10348   unsigned int jresult ;
10349   Dali::Degree arg1 ;
10350   Dali::Radian arg2 ;
10351   Dali::Degree *argp1 ;
10352   Dali::Radian *argp2 ;
10353   bool result;
10354
10355   argp1 = (Dali::Degree *)jarg1;
10356   if (!argp1) {
10357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10358     return 0;
10359   }
10360   arg1 = *argp1;
10361   argp2 = (Dali::Radian *)jarg2;
10362   if (!argp2) {
10363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10364     return 0;
10365   }
10366   arg2 = *argp2;
10367   {
10368     try {
10369       result = (bool)Dali::operator ==(arg1,arg2);
10370     } catch (std::out_of_range& e) {
10371       {
10372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10373       };
10374     } catch (std::exception& e) {
10375       {
10376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10377       };
10378     } catch (Dali::DaliException e) {
10379       {
10380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10381       };
10382     } catch (...) {
10383       {
10384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10385       };
10386     }
10387   }
10388
10389   jresult = result;
10390   return jresult;
10391 }
10392
10393
10394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10395   unsigned int jresult ;
10396   Dali::Degree arg1 ;
10397   Dali::Radian arg2 ;
10398   Dali::Degree *argp1 ;
10399   Dali::Radian *argp2 ;
10400   bool result;
10401
10402   argp1 = (Dali::Degree *)jarg1;
10403   if (!argp1) {
10404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10405     return 0;
10406   }
10407   arg1 = *argp1;
10408   argp2 = (Dali::Radian *)jarg2;
10409   if (!argp2) {
10410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10411     return 0;
10412   }
10413   arg2 = *argp2;
10414   {
10415     try {
10416       result = (bool)Dali::operator !=(arg1,arg2);
10417     } catch (std::out_of_range& e) {
10418       {
10419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10420       };
10421     } catch (std::exception& e) {
10422       {
10423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10424       };
10425     } catch (Dali::DaliException e) {
10426       {
10427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10428       };
10429     } catch (...) {
10430       {
10431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10432       };
10433     }
10434   }
10435
10436   jresult = result;
10437   return jresult;
10438 }
10439
10440
10441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10442   unsigned int jresult ;
10443   Dali::Radian arg1 ;
10444   Dali::Radian arg2 ;
10445   Dali::Radian *argp1 ;
10446   Dali::Radian *argp2 ;
10447   bool result;
10448
10449   argp1 = (Dali::Radian *)jarg1;
10450   if (!argp1) {
10451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10452     return 0;
10453   }
10454   arg1 = *argp1;
10455   argp2 = (Dali::Radian *)jarg2;
10456   if (!argp2) {
10457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10458     return 0;
10459   }
10460   arg2 = *argp2;
10461   {
10462     try {
10463       result = (bool)Dali::operator >(arg1,arg2);
10464     } catch (std::out_of_range& e) {
10465       {
10466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10467       };
10468     } catch (std::exception& e) {
10469       {
10470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10471       };
10472     } catch (Dali::DaliException e) {
10473       {
10474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10475       };
10476     } catch (...) {
10477       {
10478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10479       };
10480     }
10481   }
10482
10483   jresult = result;
10484   return jresult;
10485 }
10486
10487
10488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10489   unsigned int jresult ;
10490   Dali::Radian arg1 ;
10491   Dali::Degree arg2 ;
10492   Dali::Radian *argp1 ;
10493   Dali::Degree *argp2 ;
10494   bool result;
10495
10496   argp1 = (Dali::Radian *)jarg1;
10497   if (!argp1) {
10498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10499     return 0;
10500   }
10501   arg1 = *argp1;
10502   argp2 = (Dali::Degree *)jarg2;
10503   if (!argp2) {
10504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10505     return 0;
10506   }
10507   arg2 = *argp2;
10508   {
10509     try {
10510       result = (bool)Dali::operator >(arg1,arg2);
10511     } catch (std::out_of_range& e) {
10512       {
10513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10514       };
10515     } catch (std::exception& e) {
10516       {
10517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10518       };
10519     } catch (Dali::DaliException e) {
10520       {
10521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10522       };
10523     } catch (...) {
10524       {
10525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10526       };
10527     }
10528   }
10529
10530   jresult = result;
10531   return jresult;
10532 }
10533
10534
10535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10536   unsigned int jresult ;
10537   Dali::Degree arg1 ;
10538   Dali::Radian arg2 ;
10539   Dali::Degree *argp1 ;
10540   Dali::Radian *argp2 ;
10541   bool result;
10542
10543   argp1 = (Dali::Degree *)jarg1;
10544   if (!argp1) {
10545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10546     return 0;
10547   }
10548   arg1 = *argp1;
10549   argp2 = (Dali::Radian *)jarg2;
10550   if (!argp2) {
10551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10552     return 0;
10553   }
10554   arg2 = *argp2;
10555   {
10556     try {
10557       result = (bool)Dali::operator >(arg1,arg2);
10558     } catch (std::out_of_range& e) {
10559       {
10560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10561       };
10562     } catch (std::exception& e) {
10563       {
10564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10565       };
10566     } catch (Dali::DaliException e) {
10567       {
10568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10569       };
10570     } catch (...) {
10571       {
10572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10573       };
10574     }
10575   }
10576
10577   jresult = result;
10578   return jresult;
10579 }
10580
10581
10582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10583   unsigned int jresult ;
10584   Dali::Radian arg1 ;
10585   Dali::Radian arg2 ;
10586   Dali::Radian *argp1 ;
10587   Dali::Radian *argp2 ;
10588   bool result;
10589
10590   argp1 = (Dali::Radian *)jarg1;
10591   if (!argp1) {
10592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10593     return 0;
10594   }
10595   arg1 = *argp1;
10596   argp2 = (Dali::Radian *)jarg2;
10597   if (!argp2) {
10598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10599     return 0;
10600   }
10601   arg2 = *argp2;
10602   {
10603     try {
10604       result = (bool)Dali::operator <(arg1,arg2);
10605     } catch (std::out_of_range& e) {
10606       {
10607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10608       };
10609     } catch (std::exception& e) {
10610       {
10611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10612       };
10613     } catch (Dali::DaliException e) {
10614       {
10615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10616       };
10617     } catch (...) {
10618       {
10619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10620       };
10621     }
10622   }
10623
10624   jresult = result;
10625   return jresult;
10626 }
10627
10628
10629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10630   unsigned int jresult ;
10631   Dali::Radian arg1 ;
10632   Dali::Degree arg2 ;
10633   Dali::Radian *argp1 ;
10634   Dali::Degree *argp2 ;
10635   bool result;
10636
10637   argp1 = (Dali::Radian *)jarg1;
10638   if (!argp1) {
10639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10640     return 0;
10641   }
10642   arg1 = *argp1;
10643   argp2 = (Dali::Degree *)jarg2;
10644   if (!argp2) {
10645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10646     return 0;
10647   }
10648   arg2 = *argp2;
10649   {
10650     try {
10651       result = (bool)Dali::operator <(arg1,arg2);
10652     } catch (std::out_of_range& e) {
10653       {
10654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10655       };
10656     } catch (std::exception& e) {
10657       {
10658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10659       };
10660     } catch (Dali::DaliException e) {
10661       {
10662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10663       };
10664     } catch (...) {
10665       {
10666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10667       };
10668     }
10669   }
10670
10671   jresult = result;
10672   return jresult;
10673 }
10674
10675
10676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10677   unsigned int jresult ;
10678   Dali::Degree arg1 ;
10679   Dali::Radian arg2 ;
10680   Dali::Degree *argp1 ;
10681   Dali::Radian *argp2 ;
10682   bool result;
10683
10684   argp1 = (Dali::Degree *)jarg1;
10685   if (!argp1) {
10686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10687     return 0;
10688   }
10689   arg1 = *argp1;
10690   argp2 = (Dali::Radian *)jarg2;
10691   if (!argp2) {
10692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10693     return 0;
10694   }
10695   arg2 = *argp2;
10696   {
10697     try {
10698       result = (bool)Dali::operator <(arg1,arg2);
10699     } catch (std::out_of_range& e) {
10700       {
10701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10702       };
10703     } catch (std::exception& e) {
10704       {
10705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10706       };
10707     } catch (Dali::DaliException e) {
10708       {
10709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10710       };
10711     } catch (...) {
10712       {
10713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10714       };
10715     }
10716   }
10717
10718   jresult = result;
10719   return jresult;
10720 }
10721
10722
10723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10724   void * jresult ;
10725   Dali::Radian arg1 ;
10726   float arg2 ;
10727   Dali::Radian *argp1 ;
10728   Dali::Radian result;
10729
10730   argp1 = (Dali::Radian *)jarg1;
10731   if (!argp1) {
10732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10733     return 0;
10734   }
10735   arg1 = *argp1;
10736   arg2 = (float)jarg2;
10737   {
10738     try {
10739       result = Dali::operator *(arg1,arg2);
10740     } catch (std::out_of_range& e) {
10741       {
10742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10743       };
10744     } catch (std::exception& e) {
10745       {
10746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10747       };
10748     } catch (Dali::DaliException e) {
10749       {
10750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10751       };
10752     } catch (...) {
10753       {
10754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10755       };
10756     }
10757   }
10758
10759   jresult = new Dali::Radian((const Dali::Radian &)result);
10760   return jresult;
10761 }
10762
10763
10764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10765   void * jresult ;
10766   Dali::Radian arg1 ;
10767   Dali::Radian *argp1 ;
10768   Dali::Radian result;
10769
10770   argp1 = (Dali::Radian *)jarg1;
10771   if (!argp1) {
10772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10773     return 0;
10774   }
10775   arg1 = *argp1;
10776   {
10777     try {
10778       result = Dali::operator -(arg1);
10779     } catch (std::out_of_range& e) {
10780       {
10781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10782       };
10783     } catch (std::exception& e) {
10784       {
10785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10786       };
10787     } catch (Dali::DaliException e) {
10788       {
10789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10790       };
10791     } catch (...) {
10792       {
10793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10794       };
10795     }
10796   }
10797
10798   jresult = new Dali::Radian((const Dali::Radian &)result);
10799   return jresult;
10800 }
10801
10802
10803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10804   void * jresult ;
10805   Dali::Radian arg1 ;
10806   float arg2 ;
10807   float arg3 ;
10808   Dali::Radian *argp1 ;
10809   Dali::Radian result;
10810
10811   argp1 = (Dali::Radian *)jarg1;
10812   if (!argp1) {
10813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10814     return 0;
10815   }
10816   arg1 = *argp1;
10817   arg2 = (float)jarg2;
10818   arg3 = (float)jarg3;
10819   {
10820     try {
10821       result = Dali::Clamp(arg1,arg2,arg3);
10822     } catch (std::out_of_range& e) {
10823       {
10824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10825       };
10826     } catch (std::exception& e) {
10827       {
10828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10829       };
10830     } catch (Dali::DaliException e) {
10831       {
10832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10833       };
10834     } catch (...) {
10835       {
10836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10837       };
10838     }
10839   }
10840
10841   jresult = new Dali::Radian((const Dali::Radian &)result);
10842   return jresult;
10843 }
10844
10845
10846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10847   void * jresult ;
10848   Dali::Quaternion *result = 0 ;
10849
10850   {
10851     try {
10852       result = (Dali::Quaternion *)new Dali::Quaternion();
10853     } catch (std::out_of_range& e) {
10854       {
10855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10856       };
10857     } catch (std::exception& e) {
10858       {
10859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10860       };
10861     } catch (Dali::DaliException e) {
10862       {
10863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10864       };
10865     } catch (...) {
10866       {
10867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10868       };
10869     }
10870   }
10871
10872   jresult = (void *)result;
10873   return jresult;
10874 }
10875
10876
10877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10878   void * jresult ;
10879   Dali::Radian arg1 ;
10880   Dali::Vector3 *arg2 = 0 ;
10881   Dali::Radian *argp1 ;
10882   Dali::Quaternion *result = 0 ;
10883
10884   argp1 = (Dali::Radian *)jarg1;
10885   if (!argp1) {
10886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10887     return 0;
10888   }
10889   arg1 = *argp1;
10890   arg2 = (Dali::Vector3 *)jarg2;
10891   if (!arg2) {
10892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10893     return 0;
10894   }
10895   {
10896     try {
10897       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10898     } catch (std::out_of_range& e) {
10899       {
10900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10901       };
10902     } catch (std::exception& e) {
10903       {
10904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10905       };
10906     } catch (Dali::DaliException e) {
10907       {
10908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10909       };
10910     } catch (...) {
10911       {
10912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10913       };
10914     }
10915   }
10916
10917   jresult = (void *)result;
10918   return jresult;
10919 }
10920
10921
10922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10923   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10924
10925   arg1 = (Dali::Quaternion *)jarg1;
10926   {
10927     try {
10928       delete arg1;
10929     } catch (std::out_of_range& e) {
10930       {
10931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10932       };
10933     } catch (std::exception& e) {
10934       {
10935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10936       };
10937     } catch (Dali::DaliException e) {
10938       {
10939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10940       };
10941     } catch (...) {
10942       {
10943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10944       };
10945     }
10946   }
10947
10948 }
10949
10950
10951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10952   void * jresult ;
10953   Dali::Quaternion *result = 0 ;
10954
10955   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
10956   jresult = (void *)result;
10957   return jresult;
10958 }
10959
10960
10961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
10962   unsigned int jresult ;
10963   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10964   bool result;
10965
10966   arg1 = (Dali::Quaternion *)jarg1;
10967   {
10968     try {
10969       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
10970     } catch (std::out_of_range& e) {
10971       {
10972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10973       };
10974     } catch (std::exception& e) {
10975       {
10976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10977       };
10978     } catch (Dali::DaliException e) {
10979       {
10980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10981       };
10982     } catch (...) {
10983       {
10984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10985       };
10986     }
10987   }
10988
10989   jresult = result;
10990   return jresult;
10991 }
10992
10993
10994 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
10995   unsigned int jresult ;
10996   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10997   Dali::Vector3 *arg2 = 0 ;
10998   Dali::Radian *arg3 = 0 ;
10999   bool result;
11000
11001   arg1 = (Dali::Quaternion *)jarg1;
11002   arg2 = (Dali::Vector3 *)jarg2;
11003   if (!arg2) {
11004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11005     return 0;
11006   }
11007   arg3 = (Dali::Radian *)jarg3;
11008   if (!arg3) {
11009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11010     return 0;
11011   }
11012   {
11013     try {
11014       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11015     } catch (std::out_of_range& e) {
11016       {
11017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11018       };
11019     } catch (std::exception& e) {
11020       {
11021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11022       };
11023     } catch (Dali::DaliException e) {
11024       {
11025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11026       };
11027     } catch (...) {
11028       {
11029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11030       };
11031     }
11032   }
11033
11034   jresult = result;
11035   return jresult;
11036 }
11037
11038
11039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11040   void * jresult ;
11041   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11042   Dali::Quaternion *arg2 = 0 ;
11043   Dali::Quaternion result;
11044
11045   arg1 = (Dali::Quaternion *)jarg1;
11046   arg2 = (Dali::Quaternion *)jarg2;
11047   if (!arg2) {
11048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11049     return 0;
11050   }
11051   {
11052     try {
11053       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11054     } catch (std::out_of_range& e) {
11055       {
11056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11057       };
11058     } catch (std::exception& e) {
11059       {
11060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11061       };
11062     } catch (Dali::DaliException e) {
11063       {
11064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11065       };
11066     } catch (...) {
11067       {
11068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11069       };
11070     }
11071   }
11072
11073   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11074   return jresult;
11075 }
11076
11077
11078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11079   void * jresult ;
11080   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11081   Dali::Quaternion *arg2 = 0 ;
11082   Dali::Quaternion result;
11083
11084   arg1 = (Dali::Quaternion *)jarg1;
11085   arg2 = (Dali::Quaternion *)jarg2;
11086   if (!arg2) {
11087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11088     return 0;
11089   }
11090   {
11091     try {
11092       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11093     } catch (std::out_of_range& e) {
11094       {
11095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11096       };
11097     } catch (std::exception& e) {
11098       {
11099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11100       };
11101     } catch (Dali::DaliException e) {
11102       {
11103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11104       };
11105     } catch (...) {
11106       {
11107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11108       };
11109     }
11110   }
11111
11112   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11113   return jresult;
11114 }
11115
11116
11117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11118   void * jresult ;
11119   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11120   Dali::Quaternion *arg2 = 0 ;
11121   Dali::Quaternion result;
11122
11123   arg1 = (Dali::Quaternion *)jarg1;
11124   arg2 = (Dali::Quaternion *)jarg2;
11125   if (!arg2) {
11126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11127     return 0;
11128   }
11129   {
11130     try {
11131       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11132     } catch (std::out_of_range& e) {
11133       {
11134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11135       };
11136     } catch (std::exception& e) {
11137       {
11138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11139       };
11140     } catch (Dali::DaliException e) {
11141       {
11142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11143       };
11144     } catch (...) {
11145       {
11146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11147       };
11148     }
11149   }
11150
11151   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11152   return jresult;
11153 }
11154
11155
11156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11157   void * jresult ;
11158   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11159   Dali::Vector3 *arg2 = 0 ;
11160   Dali::Vector3 result;
11161
11162   arg1 = (Dali::Quaternion *)jarg1;
11163   arg2 = (Dali::Vector3 *)jarg2;
11164   if (!arg2) {
11165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11166     return 0;
11167   }
11168   {
11169     try {
11170       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11171     } catch (std::out_of_range& e) {
11172       {
11173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11174       };
11175     } catch (std::exception& e) {
11176       {
11177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11178       };
11179     } catch (Dali::DaliException e) {
11180       {
11181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11182       };
11183     } catch (...) {
11184       {
11185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11186       };
11187     }
11188   }
11189
11190   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11191   return jresult;
11192 }
11193
11194
11195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11196   void * jresult ;
11197   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11198   Dali::Quaternion *arg2 = 0 ;
11199   Dali::Quaternion result;
11200
11201   arg1 = (Dali::Quaternion *)jarg1;
11202   arg2 = (Dali::Quaternion *)jarg2;
11203   if (!arg2) {
11204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11205     return 0;
11206   }
11207   {
11208     try {
11209       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11210     } catch (std::out_of_range& e) {
11211       {
11212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11213       };
11214     } catch (std::exception& e) {
11215       {
11216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11217       };
11218     } catch (Dali::DaliException e) {
11219       {
11220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11221       };
11222     } catch (...) {
11223       {
11224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11225       };
11226     }
11227   }
11228
11229   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11230   return jresult;
11231 }
11232
11233
11234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11235   void * jresult ;
11236   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11237   float arg2 ;
11238   Dali::Quaternion result;
11239
11240   arg1 = (Dali::Quaternion *)jarg1;
11241   arg2 = (float)jarg2;
11242   {
11243     try {
11244       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11245     } catch (std::out_of_range& e) {
11246       {
11247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11248       };
11249     } catch (std::exception& e) {
11250       {
11251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11252       };
11253     } catch (Dali::DaliException e) {
11254       {
11255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11256       };
11257     } catch (...) {
11258       {
11259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11260       };
11261     }
11262   }
11263
11264   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11265   return jresult;
11266 }
11267
11268
11269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11270   void * jresult ;
11271   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11272   float arg2 ;
11273   Dali::Quaternion result;
11274
11275   arg1 = (Dali::Quaternion *)jarg1;
11276   arg2 = (float)jarg2;
11277   {
11278     try {
11279       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11280     } catch (std::out_of_range& e) {
11281       {
11282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11283       };
11284     } catch (std::exception& e) {
11285       {
11286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11287       };
11288     } catch (Dali::DaliException e) {
11289       {
11290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11291       };
11292     } catch (...) {
11293       {
11294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11295       };
11296     }
11297   }
11298
11299   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11300   return jresult;
11301 }
11302
11303
11304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11305   void * jresult ;
11306   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11307   Dali::Quaternion result;
11308
11309   arg1 = (Dali::Quaternion *)jarg1;
11310   {
11311     try {
11312       result = ((Dali::Quaternion const *)arg1)->operator -();
11313     } catch (std::out_of_range& e) {
11314       {
11315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11316       };
11317     } catch (std::exception& e) {
11318       {
11319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11320       };
11321     } catch (Dali::DaliException e) {
11322       {
11323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11324       };
11325     } catch (...) {
11326       {
11327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11328       };
11329     }
11330   }
11331
11332   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11333   return jresult;
11334 }
11335
11336
11337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11338   void * jresult ;
11339   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11340   Dali::Quaternion *arg2 = 0 ;
11341   Dali::Quaternion *result = 0 ;
11342
11343   arg1 = (Dali::Quaternion *)jarg1;
11344   arg2 = (Dali::Quaternion *)jarg2;
11345   if (!arg2) {
11346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11347     return 0;
11348   }
11349   {
11350     try {
11351       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11352     } catch (std::out_of_range& e) {
11353       {
11354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11355       };
11356     } catch (std::exception& e) {
11357       {
11358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11359       };
11360     } catch (Dali::DaliException e) {
11361       {
11362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11363       };
11364     } catch (...) {
11365       {
11366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11367       };
11368     }
11369   }
11370
11371   jresult = (void *)result;
11372   return jresult;
11373 }
11374
11375
11376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11377   void * jresult ;
11378   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11379   Dali::Quaternion *arg2 = 0 ;
11380   Dali::Quaternion *result = 0 ;
11381
11382   arg1 = (Dali::Quaternion *)jarg1;
11383   arg2 = (Dali::Quaternion *)jarg2;
11384   if (!arg2) {
11385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11386     return 0;
11387   }
11388   {
11389     try {
11390       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11391     } catch (std::out_of_range& e) {
11392       {
11393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11394       };
11395     } catch (std::exception& e) {
11396       {
11397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11398       };
11399     } catch (Dali::DaliException e) {
11400       {
11401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11402       };
11403     } catch (...) {
11404       {
11405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11406       };
11407     }
11408   }
11409
11410   jresult = (void *)result;
11411   return jresult;
11412 }
11413
11414
11415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11416   void * jresult ;
11417   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11418   Dali::Quaternion *arg2 = 0 ;
11419   Dali::Quaternion *result = 0 ;
11420
11421   arg1 = (Dali::Quaternion *)jarg1;
11422   arg2 = (Dali::Quaternion *)jarg2;
11423   if (!arg2) {
11424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11425     return 0;
11426   }
11427   {
11428     try {
11429       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11430     } catch (std::out_of_range& e) {
11431       {
11432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11433       };
11434     } catch (std::exception& e) {
11435       {
11436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11437       };
11438     } catch (Dali::DaliException e) {
11439       {
11440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11441       };
11442     } catch (...) {
11443       {
11444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11445       };
11446     }
11447   }
11448
11449   jresult = (void *)result;
11450   return jresult;
11451 }
11452
11453
11454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11455   void * jresult ;
11456   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11457   float arg2 ;
11458   Dali::Quaternion *result = 0 ;
11459
11460   arg1 = (Dali::Quaternion *)jarg1;
11461   arg2 = (float)jarg2;
11462   {
11463     try {
11464       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11465     } catch (std::out_of_range& e) {
11466       {
11467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11468       };
11469     } catch (std::exception& e) {
11470       {
11471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11472       };
11473     } catch (Dali::DaliException e) {
11474       {
11475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11476       };
11477     } catch (...) {
11478       {
11479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11480       };
11481     }
11482   }
11483
11484   jresult = (void *)result;
11485   return jresult;
11486 }
11487
11488
11489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11490   void * jresult ;
11491   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11492   float arg2 ;
11493   Dali::Quaternion *result = 0 ;
11494
11495   arg1 = (Dali::Quaternion *)jarg1;
11496   arg2 = (float)jarg2;
11497   {
11498     try {
11499       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11500     } catch (std::out_of_range& e) {
11501       {
11502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11503       };
11504     } catch (std::exception& e) {
11505       {
11506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11507       };
11508     } catch (Dali::DaliException e) {
11509       {
11510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11511       };
11512     } catch (...) {
11513       {
11514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11515       };
11516     }
11517   }
11518
11519   jresult = (void *)result;
11520   return jresult;
11521 }
11522
11523
11524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11525   unsigned int jresult ;
11526   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11527   Dali::Quaternion *arg2 = 0 ;
11528   bool result;
11529
11530   arg1 = (Dali::Quaternion *)jarg1;
11531   arg2 = (Dali::Quaternion *)jarg2;
11532   if (!arg2) {
11533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11534     return 0;
11535   }
11536   {
11537     try {
11538       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11539     } catch (std::out_of_range& e) {
11540       {
11541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11542       };
11543     } catch (std::exception& e) {
11544       {
11545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11546       };
11547     } catch (Dali::DaliException e) {
11548       {
11549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11550       };
11551     } catch (...) {
11552       {
11553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11554       };
11555     }
11556   }
11557
11558   jresult = result;
11559   return jresult;
11560 }
11561
11562
11563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11564   unsigned int jresult ;
11565   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11566   Dali::Quaternion *arg2 = 0 ;
11567   bool result;
11568
11569   arg1 = (Dali::Quaternion *)jarg1;
11570   arg2 = (Dali::Quaternion *)jarg2;
11571   if (!arg2) {
11572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11573     return 0;
11574   }
11575   {
11576     try {
11577       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11578     } catch (std::out_of_range& e) {
11579       {
11580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11581       };
11582     } catch (std::exception& e) {
11583       {
11584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11585       };
11586     } catch (Dali::DaliException e) {
11587       {
11588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11589       };
11590     } catch (...) {
11591       {
11592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11593       };
11594     }
11595   }
11596
11597   jresult = result;
11598   return jresult;
11599 }
11600
11601
11602 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11603   float jresult ;
11604   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11605   float result;
11606
11607   arg1 = (Dali::Quaternion *)jarg1;
11608   {
11609     try {
11610       result = (float)((Dali::Quaternion const *)arg1)->Length();
11611     } catch (std::out_of_range& e) {
11612       {
11613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11614       };
11615     } catch (std::exception& e) {
11616       {
11617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11618       };
11619     } catch (Dali::DaliException e) {
11620       {
11621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11622       };
11623     } catch (...) {
11624       {
11625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11626       };
11627     }
11628   }
11629
11630   jresult = result;
11631   return jresult;
11632 }
11633
11634
11635 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11636   float jresult ;
11637   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11638   float result;
11639
11640   arg1 = (Dali::Quaternion *)jarg1;
11641   {
11642     try {
11643       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11644     } catch (std::out_of_range& e) {
11645       {
11646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11647       };
11648     } catch (std::exception& e) {
11649       {
11650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11651       };
11652     } catch (Dali::DaliException e) {
11653       {
11654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11655       };
11656     } catch (...) {
11657       {
11658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11659       };
11660     }
11661   }
11662
11663   jresult = result;
11664   return jresult;
11665 }
11666
11667
11668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11669   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11670
11671   arg1 = (Dali::Quaternion *)jarg1;
11672   {
11673     try {
11674       (arg1)->Normalize();
11675     } catch (std::out_of_range& e) {
11676       {
11677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11678       };
11679     } catch (std::exception& e) {
11680       {
11681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11682       };
11683     } catch (Dali::DaliException e) {
11684       {
11685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11686       };
11687     } catch (...) {
11688       {
11689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11690       };
11691     }
11692   }
11693
11694 }
11695
11696
11697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11698   void * jresult ;
11699   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11700   Dali::Quaternion result;
11701
11702   arg1 = (Dali::Quaternion *)jarg1;
11703   {
11704     try {
11705       result = ((Dali::Quaternion const *)arg1)->Normalized();
11706     } catch (std::out_of_range& e) {
11707       {
11708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11709       };
11710     } catch (std::exception& e) {
11711       {
11712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11713       };
11714     } catch (Dali::DaliException e) {
11715       {
11716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11717       };
11718     } catch (...) {
11719       {
11720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11721       };
11722     }
11723   }
11724
11725   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11726   return jresult;
11727 }
11728
11729
11730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11731   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11732
11733   arg1 = (Dali::Quaternion *)jarg1;
11734   {
11735     try {
11736       (arg1)->Conjugate();
11737     } catch (std::out_of_range& e) {
11738       {
11739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11740       };
11741     } catch (std::exception& e) {
11742       {
11743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11744       };
11745     } catch (Dali::DaliException e) {
11746       {
11747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11748       };
11749     } catch (...) {
11750       {
11751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11752       };
11753     }
11754   }
11755
11756 }
11757
11758
11759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11760   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11761
11762   arg1 = (Dali::Quaternion *)jarg1;
11763   {
11764     try {
11765       (arg1)->Invert();
11766     } catch (std::out_of_range& e) {
11767       {
11768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11769       };
11770     } catch (std::exception& e) {
11771       {
11772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11773       };
11774     } catch (Dali::DaliException e) {
11775       {
11776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11777       };
11778     } catch (...) {
11779       {
11780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11781       };
11782     }
11783   }
11784
11785 }
11786
11787
11788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11789   void * jresult ;
11790   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11791   Dali::Quaternion result;
11792
11793   arg1 = (Dali::Quaternion *)jarg1;
11794   {
11795     try {
11796       result = ((Dali::Quaternion const *)arg1)->Log();
11797     } catch (std::out_of_range& e) {
11798       {
11799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11800       };
11801     } catch (std::exception& e) {
11802       {
11803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11804       };
11805     } catch (Dali::DaliException e) {
11806       {
11807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11808       };
11809     } catch (...) {
11810       {
11811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11812       };
11813     }
11814   }
11815
11816   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11817   return jresult;
11818 }
11819
11820
11821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11822   void * jresult ;
11823   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11824   Dali::Quaternion result;
11825
11826   arg1 = (Dali::Quaternion *)jarg1;
11827   {
11828     try {
11829       result = ((Dali::Quaternion const *)arg1)->Exp();
11830     } catch (std::out_of_range& e) {
11831       {
11832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11833       };
11834     } catch (std::exception& e) {
11835       {
11836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11837       };
11838     } catch (Dali::DaliException e) {
11839       {
11840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11841       };
11842     } catch (...) {
11843       {
11844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11845       };
11846     }
11847   }
11848
11849   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11850   return jresult;
11851 }
11852
11853
11854 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11855   float jresult ;
11856   Dali::Quaternion *arg1 = 0 ;
11857   Dali::Quaternion *arg2 = 0 ;
11858   float result;
11859
11860   arg1 = (Dali::Quaternion *)jarg1;
11861   if (!arg1) {
11862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11863     return 0;
11864   }
11865   arg2 = (Dali::Quaternion *)jarg2;
11866   if (!arg2) {
11867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11868     return 0;
11869   }
11870   {
11871     try {
11872       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11873     } catch (std::out_of_range& e) {
11874       {
11875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11876       };
11877     } catch (std::exception& e) {
11878       {
11879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11880       };
11881     } catch (Dali::DaliException e) {
11882       {
11883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11884       };
11885     } catch (...) {
11886       {
11887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11888       };
11889     }
11890   }
11891
11892   jresult = result;
11893   return jresult;
11894 }
11895
11896
11897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11898   void * jresult ;
11899   Dali::Quaternion *arg1 = 0 ;
11900   Dali::Quaternion *arg2 = 0 ;
11901   float arg3 ;
11902   Dali::Quaternion result;
11903
11904   arg1 = (Dali::Quaternion *)jarg1;
11905   if (!arg1) {
11906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11907     return 0;
11908   }
11909   arg2 = (Dali::Quaternion *)jarg2;
11910   if (!arg2) {
11911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11912     return 0;
11913   }
11914   arg3 = (float)jarg3;
11915   {
11916     try {
11917       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11918     } catch (std::out_of_range& e) {
11919       {
11920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11921       };
11922     } catch (std::exception& e) {
11923       {
11924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11925       };
11926     } catch (Dali::DaliException e) {
11927       {
11928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11929       };
11930     } catch (...) {
11931       {
11932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11933       };
11934     }
11935   }
11936
11937   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11938   return jresult;
11939 }
11940
11941
11942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11943   void * jresult ;
11944   Dali::Quaternion *arg1 = 0 ;
11945   Dali::Quaternion *arg2 = 0 ;
11946   float arg3 ;
11947   Dali::Quaternion result;
11948
11949   arg1 = (Dali::Quaternion *)jarg1;
11950   if (!arg1) {
11951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11952     return 0;
11953   }
11954   arg2 = (Dali::Quaternion *)jarg2;
11955   if (!arg2) {
11956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11957     return 0;
11958   }
11959   arg3 = (float)jarg3;
11960   {
11961     try {
11962       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11963     } catch (std::out_of_range& e) {
11964       {
11965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11966       };
11967     } catch (std::exception& e) {
11968       {
11969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11970       };
11971     } catch (Dali::DaliException e) {
11972       {
11973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11974       };
11975     } catch (...) {
11976       {
11977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11978       };
11979     }
11980   }
11981
11982   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11983   return jresult;
11984 }
11985
11986
11987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
11988   void * jresult ;
11989   Dali::Quaternion *arg1 = 0 ;
11990   Dali::Quaternion *arg2 = 0 ;
11991   float arg3 ;
11992   Dali::Quaternion result;
11993
11994   arg1 = (Dali::Quaternion *)jarg1;
11995   if (!arg1) {
11996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11997     return 0;
11998   }
11999   arg2 = (Dali::Quaternion *)jarg2;
12000   if (!arg2) {
12001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12002     return 0;
12003   }
12004   arg3 = (float)jarg3;
12005   {
12006     try {
12007       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12008     } catch (std::out_of_range& e) {
12009       {
12010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12011       };
12012     } catch (std::exception& e) {
12013       {
12014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12015       };
12016     } catch (Dali::DaliException e) {
12017       {
12018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12019       };
12020     } catch (...) {
12021       {
12022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12023       };
12024     }
12025   }
12026
12027   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12028   return jresult;
12029 }
12030
12031
12032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12033   void * jresult ;
12034   Dali::Quaternion *arg1 = 0 ;
12035   Dali::Quaternion *arg2 = 0 ;
12036   Dali::Quaternion *arg3 = 0 ;
12037   Dali::Quaternion *arg4 = 0 ;
12038   float arg5 ;
12039   Dali::Quaternion result;
12040
12041   arg1 = (Dali::Quaternion *)jarg1;
12042   if (!arg1) {
12043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12044     return 0;
12045   }
12046   arg2 = (Dali::Quaternion *)jarg2;
12047   if (!arg2) {
12048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12049     return 0;
12050   }
12051   arg3 = (Dali::Quaternion *)jarg3;
12052   if (!arg3) {
12053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12054     return 0;
12055   }
12056   arg4 = (Dali::Quaternion *)jarg4;
12057   if (!arg4) {
12058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12059     return 0;
12060   }
12061   arg5 = (float)jarg5;
12062   {
12063     try {
12064       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12065     } catch (std::out_of_range& e) {
12066       {
12067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12068       };
12069     } catch (std::exception& e) {
12070       {
12071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12072       };
12073     } catch (Dali::DaliException e) {
12074       {
12075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12076       };
12077     } catch (...) {
12078       {
12079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12080       };
12081     }
12082   }
12083
12084   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12085   return jresult;
12086 }
12087
12088
12089 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12090   float jresult ;
12091   Dali::Quaternion *arg1 = 0 ;
12092   Dali::Quaternion *arg2 = 0 ;
12093   float result;
12094
12095   arg1 = (Dali::Quaternion *)jarg1;
12096   if (!arg1) {
12097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12098     return 0;
12099   }
12100   arg2 = (Dali::Quaternion *)jarg2;
12101   if (!arg2) {
12102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12103     return 0;
12104   }
12105   {
12106     try {
12107       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12108     } catch (std::out_of_range& e) {
12109       {
12110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12111       };
12112     } catch (std::exception& e) {
12113       {
12114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12115       };
12116     } catch (Dali::DaliException e) {
12117       {
12118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12119       };
12120     } catch (...) {
12121       {
12122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12123       };
12124     }
12125   }
12126
12127   jresult = result;
12128   return jresult;
12129 }
12130
12131
12132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12133   void * jresult ;
12134   Dali::Matrix *result = 0 ;
12135
12136   {
12137     try {
12138       result = (Dali::Matrix *)new Dali::Matrix();
12139     } catch (std::out_of_range& e) {
12140       {
12141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12142       };
12143     } catch (std::exception& e) {
12144       {
12145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12146       };
12147     } catch (Dali::DaliException e) {
12148       {
12149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12150       };
12151     } catch (...) {
12152       {
12153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12154       };
12155     }
12156   }
12157
12158   jresult = (void *)result;
12159   return jresult;
12160 }
12161
12162
12163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12164   void * jresult ;
12165   bool arg1 ;
12166   Dali::Matrix *result = 0 ;
12167
12168   arg1 = jarg1 ? true : false;
12169   {
12170     try {
12171       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12172     } catch (std::out_of_range& e) {
12173       {
12174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12175       };
12176     } catch (std::exception& e) {
12177       {
12178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12179       };
12180     } catch (Dali::DaliException e) {
12181       {
12182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12183       };
12184     } catch (...) {
12185       {
12186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12187       };
12188     }
12189   }
12190
12191   jresult = (void *)result;
12192   return jresult;
12193 }
12194
12195
12196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12197   void * jresult ;
12198   float *arg1 = (float *) 0 ;
12199   Dali::Matrix *result = 0 ;
12200
12201   arg1 = jarg1;
12202   {
12203     try {
12204       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12205     } catch (std::out_of_range& e) {
12206       {
12207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12208       };
12209     } catch (std::exception& e) {
12210       {
12211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12212       };
12213     } catch (Dali::DaliException e) {
12214       {
12215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12216       };
12217     } catch (...) {
12218       {
12219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12220       };
12221     }
12222   }
12223
12224   jresult = (void *)result;
12225
12226
12227   return jresult;
12228 }
12229
12230
12231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12232   void * jresult ;
12233   Dali::Quaternion *arg1 = 0 ;
12234   Dali::Matrix *result = 0 ;
12235
12236   arg1 = (Dali::Quaternion *)jarg1;
12237   if (!arg1) {
12238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12239     return 0;
12240   }
12241   {
12242     try {
12243       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12244     } catch (std::out_of_range& e) {
12245       {
12246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12247       };
12248     } catch (std::exception& e) {
12249       {
12250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12251       };
12252     } catch (Dali::DaliException e) {
12253       {
12254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12255       };
12256     } catch (...) {
12257       {
12258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12259       };
12260     }
12261   }
12262
12263   jresult = (void *)result;
12264   return jresult;
12265 }
12266
12267
12268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12269   void * jresult ;
12270   Dali::Matrix *arg1 = 0 ;
12271   Dali::Matrix *result = 0 ;
12272
12273   arg1 = (Dali::Matrix *)jarg1;
12274   if (!arg1) {
12275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12276     return 0;
12277   }
12278   {
12279     try {
12280       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12281     } catch (std::out_of_range& e) {
12282       {
12283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12284       };
12285     } catch (std::exception& e) {
12286       {
12287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12288       };
12289     } catch (Dali::DaliException e) {
12290       {
12291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12292       };
12293     } catch (...) {
12294       {
12295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12296       };
12297     }
12298   }
12299
12300   jresult = (void *)result;
12301   return jresult;
12302 }
12303
12304
12305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12306   void * jresult ;
12307   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12308   Dali::Matrix *arg2 = 0 ;
12309   Dali::Matrix *result = 0 ;
12310
12311   arg1 = (Dali::Matrix *)jarg1;
12312   arg2 = (Dali::Matrix *)jarg2;
12313   if (!arg2) {
12314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12315     return 0;
12316   }
12317   {
12318     try {
12319       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12320     } catch (std::out_of_range& e) {
12321       {
12322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12323       };
12324     } catch (std::exception& e) {
12325       {
12326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12327       };
12328     } catch (Dali::DaliException e) {
12329       {
12330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12331       };
12332     } catch (...) {
12333       {
12334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12335       };
12336     }
12337   }
12338
12339   jresult = (void *)result;
12340   return jresult;
12341 }
12342
12343
12344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12345   void * jresult ;
12346   Dali::Matrix *result = 0 ;
12347
12348   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12349   jresult = (void *)result;
12350   return jresult;
12351 }
12352
12353
12354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12355   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12356
12357   arg1 = (Dali::Matrix *)jarg1;
12358   {
12359     try {
12360       (arg1)->SetIdentity();
12361     } catch (std::out_of_range& e) {
12362       {
12363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12364       };
12365     } catch (std::exception& e) {
12366       {
12367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12368       };
12369     } catch (Dali::DaliException e) {
12370       {
12371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12372       };
12373     } catch (...) {
12374       {
12375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12376       };
12377     }
12378   }
12379
12380 }
12381
12382
12383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12384   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12385   Dali::Vector3 *arg2 = 0 ;
12386
12387   arg1 = (Dali::Matrix *)jarg1;
12388   arg2 = (Dali::Vector3 *)jarg2;
12389   if (!arg2) {
12390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12391     return ;
12392   }
12393   {
12394     try {
12395       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12396     } catch (std::out_of_range& e) {
12397       {
12398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12399       };
12400     } catch (std::exception& e) {
12401       {
12402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12403       };
12404     } catch (Dali::DaliException e) {
12405       {
12406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12407       };
12408     } catch (...) {
12409       {
12410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12411       };
12412     }
12413   }
12414
12415 }
12416
12417
12418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12419   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12420   Dali::Matrix *arg2 = 0 ;
12421
12422   arg1 = (Dali::Matrix *)jarg1;
12423   arg2 = (Dali::Matrix *)jarg2;
12424   if (!arg2) {
12425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12426     return ;
12427   }
12428   {
12429     try {
12430       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12431     } catch (std::out_of_range& e) {
12432       {
12433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12434       };
12435     } catch (std::exception& e) {
12436       {
12437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12438       };
12439     } catch (Dali::DaliException e) {
12440       {
12441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12442       };
12443     } catch (...) {
12444       {
12445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12446       };
12447     }
12448   }
12449
12450 }
12451
12452
12453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12454   unsigned int jresult ;
12455   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12456   bool result;
12457
12458   arg1 = (Dali::Matrix *)jarg1;
12459   {
12460     try {
12461       result = (bool)(arg1)->Invert();
12462     } catch (std::out_of_range& e) {
12463       {
12464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12465       };
12466     } catch (std::exception& e) {
12467       {
12468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12469       };
12470     } catch (Dali::DaliException e) {
12471       {
12472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12473       };
12474     } catch (...) {
12475       {
12476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12477       };
12478     }
12479   }
12480
12481   jresult = result;
12482   return jresult;
12483 }
12484
12485
12486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12487   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12488
12489   arg1 = (Dali::Matrix *)jarg1;
12490   {
12491     try {
12492       (arg1)->Transpose();
12493     } catch (std::out_of_range& e) {
12494       {
12495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12496       };
12497     } catch (std::exception& e) {
12498       {
12499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12500       };
12501     } catch (Dali::DaliException e) {
12502       {
12503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12504       };
12505     } catch (...) {
12506       {
12507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12508       };
12509     }
12510   }
12511
12512 }
12513
12514
12515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12516   void * jresult ;
12517   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12518   Dali::Vector3 result;
12519
12520   arg1 = (Dali::Matrix *)jarg1;
12521   {
12522     try {
12523       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12524     } catch (std::out_of_range& e) {
12525       {
12526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12527       };
12528     } catch (std::exception& e) {
12529       {
12530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12531       };
12532     } catch (Dali::DaliException e) {
12533       {
12534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12535       };
12536     } catch (...) {
12537       {
12538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12539       };
12540     }
12541   }
12542
12543   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12544   return jresult;
12545 }
12546
12547
12548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12549   void * jresult ;
12550   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12551   Dali::Vector3 result;
12552
12553   arg1 = (Dali::Matrix *)jarg1;
12554   {
12555     try {
12556       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12557     } catch (std::out_of_range& e) {
12558       {
12559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12560       };
12561     } catch (std::exception& e) {
12562       {
12563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12564       };
12565     } catch (Dali::DaliException e) {
12566       {
12567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12568       };
12569     } catch (...) {
12570       {
12571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12572       };
12573     }
12574   }
12575
12576   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12577   return jresult;
12578 }
12579
12580
12581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12582   void * jresult ;
12583   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12584   Dali::Vector3 result;
12585
12586   arg1 = (Dali::Matrix *)jarg1;
12587   {
12588     try {
12589       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12590     } catch (std::out_of_range& e) {
12591       {
12592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12593       };
12594     } catch (std::exception& e) {
12595       {
12596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12597       };
12598     } catch (Dali::DaliException e) {
12599       {
12600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12601       };
12602     } catch (...) {
12603       {
12604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12605       };
12606     }
12607   }
12608
12609   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12610   return jresult;
12611 }
12612
12613
12614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12615   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12616   Dali::Vector3 *arg2 = 0 ;
12617
12618   arg1 = (Dali::Matrix *)jarg1;
12619   arg2 = (Dali::Vector3 *)jarg2;
12620   if (!arg2) {
12621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12622     return ;
12623   }
12624   {
12625     try {
12626       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12627     } catch (std::out_of_range& e) {
12628       {
12629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12630       };
12631     } catch (std::exception& e) {
12632       {
12633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12634       };
12635     } catch (Dali::DaliException e) {
12636       {
12637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12638       };
12639     } catch (...) {
12640       {
12641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12642       };
12643     }
12644   }
12645
12646 }
12647
12648
12649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12650   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12651   Dali::Vector3 *arg2 = 0 ;
12652
12653   arg1 = (Dali::Matrix *)jarg1;
12654   arg2 = (Dali::Vector3 *)jarg2;
12655   if (!arg2) {
12656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12657     return ;
12658   }
12659   {
12660     try {
12661       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12662     } catch (std::out_of_range& e) {
12663       {
12664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12665       };
12666     } catch (std::exception& e) {
12667       {
12668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12669       };
12670     } catch (Dali::DaliException e) {
12671       {
12672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12673       };
12674     } catch (...) {
12675       {
12676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12677       };
12678     }
12679   }
12680
12681 }
12682
12683
12684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12685   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12686   Dali::Vector3 *arg2 = 0 ;
12687
12688   arg1 = (Dali::Matrix *)jarg1;
12689   arg2 = (Dali::Vector3 *)jarg2;
12690   if (!arg2) {
12691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12692     return ;
12693   }
12694   {
12695     try {
12696       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12697     } catch (std::out_of_range& e) {
12698       {
12699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12700       };
12701     } catch (std::exception& e) {
12702       {
12703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12704       };
12705     } catch (Dali::DaliException e) {
12706       {
12707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12708       };
12709     } catch (...) {
12710       {
12711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12712       };
12713     }
12714   }
12715
12716 }
12717
12718
12719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12720   void * jresult ;
12721   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12722   Dali::Vector4 *result = 0 ;
12723
12724   arg1 = (Dali::Matrix *)jarg1;
12725   {
12726     try {
12727       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12728     } catch (std::out_of_range& e) {
12729       {
12730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12731       };
12732     } catch (std::exception& e) {
12733       {
12734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12735       };
12736     } catch (Dali::DaliException e) {
12737       {
12738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12739       };
12740     } catch (...) {
12741       {
12742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12743       };
12744     }
12745   }
12746
12747   jresult = (void *)result;
12748   return jresult;
12749 }
12750
12751
12752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12753   void * jresult ;
12754   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12755   Dali::Vector3 *result = 0 ;
12756
12757   arg1 = (Dali::Matrix *)jarg1;
12758   {
12759     try {
12760       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12761     } catch (std::out_of_range& e) {
12762       {
12763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12764       };
12765     } catch (std::exception& e) {
12766       {
12767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12768       };
12769     } catch (Dali::DaliException e) {
12770       {
12771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12772       };
12773     } catch (...) {
12774       {
12775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12776       };
12777     }
12778   }
12779
12780   jresult = (void *)result;
12781   return jresult;
12782 }
12783
12784
12785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12786   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12787   Dali::Vector4 *arg2 = 0 ;
12788
12789   arg1 = (Dali::Matrix *)jarg1;
12790   arg2 = (Dali::Vector4 *)jarg2;
12791   if (!arg2) {
12792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12793     return ;
12794   }
12795   {
12796     try {
12797       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12798     } catch (std::out_of_range& e) {
12799       {
12800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12801       };
12802     } catch (std::exception& e) {
12803       {
12804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12805       };
12806     } catch (Dali::DaliException e) {
12807       {
12808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12809       };
12810     } catch (...) {
12811       {
12812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12813       };
12814     }
12815   }
12816
12817 }
12818
12819
12820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12821   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12822   Dali::Vector3 *arg2 = 0 ;
12823
12824   arg1 = (Dali::Matrix *)jarg1;
12825   arg2 = (Dali::Vector3 *)jarg2;
12826   if (!arg2) {
12827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12828     return ;
12829   }
12830   {
12831     try {
12832       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12833     } catch (std::out_of_range& e) {
12834       {
12835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12836       };
12837     } catch (std::exception& e) {
12838       {
12839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12840       };
12841     } catch (Dali::DaliException e) {
12842       {
12843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12844       };
12845     } catch (...) {
12846       {
12847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12848       };
12849     }
12850   }
12851
12852 }
12853
12854
12855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12856   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12857
12858   arg1 = (Dali::Matrix *)jarg1;
12859   {
12860     try {
12861       (arg1)->OrthoNormalize();
12862     } catch (std::out_of_range& e) {
12863       {
12864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12865       };
12866     } catch (std::exception& e) {
12867       {
12868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12869       };
12870     } catch (Dali::DaliException e) {
12871       {
12872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12873       };
12874     } catch (...) {
12875       {
12876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12877       };
12878     }
12879   }
12880
12881 }
12882
12883
12884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12885   void * jresult ;
12886   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12887   float *result = 0 ;
12888
12889   arg1 = (Dali::Matrix *)jarg1;
12890   {
12891     try {
12892       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12893     } catch (std::out_of_range& e) {
12894       {
12895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12896       };
12897     } catch (std::exception& e) {
12898       {
12899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12900       };
12901     } catch (Dali::DaliException e) {
12902       {
12903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12904       };
12905     } catch (...) {
12906       {
12907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12908       };
12909     }
12910   }
12911
12912   jresult = (void *)result;
12913   return jresult;
12914 }
12915
12916
12917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12918   Dali::Matrix *arg1 = 0 ;
12919   Dali::Matrix *arg2 = 0 ;
12920   Dali::Matrix *arg3 = 0 ;
12921
12922   arg1 = (Dali::Matrix *)jarg1;
12923   if (!arg1) {
12924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12925     return ;
12926   }
12927   arg2 = (Dali::Matrix *)jarg2;
12928   if (!arg2) {
12929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12930     return ;
12931   }
12932   arg3 = (Dali::Matrix *)jarg3;
12933   if (!arg3) {
12934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12935     return ;
12936   }
12937   {
12938     try {
12939       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12940     } catch (std::out_of_range& e) {
12941       {
12942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12943       };
12944     } catch (std::exception& e) {
12945       {
12946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12947       };
12948     } catch (Dali::DaliException e) {
12949       {
12950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12951       };
12952     } catch (...) {
12953       {
12954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12955       };
12956     }
12957   }
12958
12959 }
12960
12961
12962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
12963   Dali::Matrix *arg1 = 0 ;
12964   Dali::Matrix *arg2 = 0 ;
12965   Dali::Quaternion *arg3 = 0 ;
12966
12967   arg1 = (Dali::Matrix *)jarg1;
12968   if (!arg1) {
12969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12970     return ;
12971   }
12972   arg2 = (Dali::Matrix *)jarg2;
12973   if (!arg2) {
12974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12975     return ;
12976   }
12977   arg3 = (Dali::Quaternion *)jarg3;
12978   if (!arg3) {
12979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12980     return ;
12981   }
12982   {
12983     try {
12984       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
12985     } catch (std::out_of_range& e) {
12986       {
12987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12988       };
12989     } catch (std::exception& e) {
12990       {
12991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12992       };
12993     } catch (Dali::DaliException e) {
12994       {
12995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12996       };
12997     } catch (...) {
12998       {
12999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13000       };
13001     }
13002   }
13003
13004 }
13005
13006
13007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13008   void * jresult ;
13009   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13010   Dali::Vector4 *arg2 = 0 ;
13011   Dali::Vector4 result;
13012
13013   arg1 = (Dali::Matrix *)jarg1;
13014   arg2 = (Dali::Vector4 *)jarg2;
13015   if (!arg2) {
13016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13017     return 0;
13018   }
13019   {
13020     try {
13021       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13022     } catch (std::out_of_range& e) {
13023       {
13024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13025       };
13026     } catch (std::exception& e) {
13027       {
13028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13029       };
13030     } catch (Dali::DaliException e) {
13031       {
13032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13033       };
13034     } catch (...) {
13035       {
13036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13037       };
13038     }
13039   }
13040
13041   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13042   return jresult;
13043 }
13044
13045
13046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13047   unsigned int jresult ;
13048   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13049   Dali::Matrix *arg2 = 0 ;
13050   bool result;
13051
13052   arg1 = (Dali::Matrix *)jarg1;
13053   arg2 = (Dali::Matrix *)jarg2;
13054   if (!arg2) {
13055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13056     return 0;
13057   }
13058   {
13059     try {
13060       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13061     } catch (std::out_of_range& e) {
13062       {
13063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13064       };
13065     } catch (std::exception& e) {
13066       {
13067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13068       };
13069     } catch (Dali::DaliException e) {
13070       {
13071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13072       };
13073     } catch (...) {
13074       {
13075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13076       };
13077     }
13078   }
13079
13080   jresult = result;
13081   return jresult;
13082 }
13083
13084
13085 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13086   unsigned int jresult ;
13087   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13088   Dali::Matrix *arg2 = 0 ;
13089   bool result;
13090
13091   arg1 = (Dali::Matrix *)jarg1;
13092   arg2 = (Dali::Matrix *)jarg2;
13093   if (!arg2) {
13094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13095     return 0;
13096   }
13097   {
13098     try {
13099       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13100     } catch (std::out_of_range& e) {
13101       {
13102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13103       };
13104     } catch (std::exception& e) {
13105       {
13106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13107       };
13108     } catch (Dali::DaliException e) {
13109       {
13110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13111       };
13112     } catch (...) {
13113       {
13114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13115       };
13116     }
13117   }
13118
13119   jresult = result;
13120   return jresult;
13121 }
13122
13123
13124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13125   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13126   Dali::Vector3 *arg2 = 0 ;
13127   Dali::Quaternion *arg3 = 0 ;
13128   Dali::Vector3 *arg4 = 0 ;
13129
13130   arg1 = (Dali::Matrix *)jarg1;
13131   arg2 = (Dali::Vector3 *)jarg2;
13132   if (!arg2) {
13133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13134     return ;
13135   }
13136   arg3 = (Dali::Quaternion *)jarg3;
13137   if (!arg3) {
13138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13139     return ;
13140   }
13141   arg4 = (Dali::Vector3 *)jarg4;
13142   if (!arg4) {
13143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13144     return ;
13145   }
13146   {
13147     try {
13148       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13149     } catch (std::out_of_range& e) {
13150       {
13151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13152       };
13153     } catch (std::exception& e) {
13154       {
13155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13156       };
13157     } catch (Dali::DaliException e) {
13158       {
13159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13160       };
13161     } catch (...) {
13162       {
13163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13164       };
13165     }
13166   }
13167
13168 }
13169
13170
13171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13172   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13173   Dali::Vector3 *arg2 = 0 ;
13174   Dali::Quaternion *arg3 = 0 ;
13175   Dali::Vector3 *arg4 = 0 ;
13176
13177   arg1 = (Dali::Matrix *)jarg1;
13178   arg2 = (Dali::Vector3 *)jarg2;
13179   if (!arg2) {
13180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13181     return ;
13182   }
13183   arg3 = (Dali::Quaternion *)jarg3;
13184   if (!arg3) {
13185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13186     return ;
13187   }
13188   arg4 = (Dali::Vector3 *)jarg4;
13189   if (!arg4) {
13190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13191     return ;
13192   }
13193   {
13194     try {
13195       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13196     } catch (std::out_of_range& e) {
13197       {
13198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13199       };
13200     } catch (std::exception& e) {
13201       {
13202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13203       };
13204     } catch (Dali::DaliException e) {
13205       {
13206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13207       };
13208     } catch (...) {
13209       {
13210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13211       };
13212     }
13213   }
13214
13215 }
13216
13217
13218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13219   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13220   Dali::Vector3 *arg2 = 0 ;
13221   Dali::Vector3 *arg3 = 0 ;
13222   Dali::Vector3 *arg4 = 0 ;
13223   Dali::Vector3 *arg5 = 0 ;
13224
13225   arg1 = (Dali::Matrix *)jarg1;
13226   arg2 = (Dali::Vector3 *)jarg2;
13227   if (!arg2) {
13228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13229     return ;
13230   }
13231   arg3 = (Dali::Vector3 *)jarg3;
13232   if (!arg3) {
13233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13234     return ;
13235   }
13236   arg4 = (Dali::Vector3 *)jarg4;
13237   if (!arg4) {
13238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13239     return ;
13240   }
13241   arg5 = (Dali::Vector3 *)jarg5;
13242   if (!arg5) {
13243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13244     return ;
13245   }
13246   {
13247     try {
13248       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13249     } catch (std::out_of_range& e) {
13250       {
13251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13252       };
13253     } catch (std::exception& e) {
13254       {
13255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13256       };
13257     } catch (Dali::DaliException e) {
13258       {
13259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13260       };
13261     } catch (...) {
13262       {
13263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13264       };
13265     }
13266   }
13267
13268 }
13269
13270
13271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13272   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13273   Dali::Vector3 *arg2 = 0 ;
13274   Dali::Quaternion *arg3 = 0 ;
13275   Dali::Vector3 *arg4 = 0 ;
13276
13277   arg1 = (Dali::Matrix *)jarg1;
13278   arg2 = (Dali::Vector3 *)jarg2;
13279   if (!arg2) {
13280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13281     return ;
13282   }
13283   arg3 = (Dali::Quaternion *)jarg3;
13284   if (!arg3) {
13285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13286     return ;
13287   }
13288   arg4 = (Dali::Vector3 *)jarg4;
13289   if (!arg4) {
13290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13291     return ;
13292   }
13293   {
13294     try {
13295       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13296     } catch (std::out_of_range& e) {
13297       {
13298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13299       };
13300     } catch (std::exception& e) {
13301       {
13302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13303       };
13304     } catch (Dali::DaliException e) {
13305       {
13306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13307       };
13308     } catch (...) {
13309       {
13310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13311       };
13312     }
13313   }
13314
13315 }
13316
13317
13318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13319   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13320
13321   arg1 = (Dali::Matrix *)jarg1;
13322   {
13323     try {
13324       delete arg1;
13325     } catch (std::out_of_range& e) {
13326       {
13327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13328       };
13329     } catch (std::exception& e) {
13330       {
13331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13332       };
13333     } catch (Dali::DaliException e) {
13334       {
13335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13336       };
13337     } catch (...) {
13338       {
13339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13340       };
13341     }
13342   }
13343
13344 }
13345
13346
13347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13348   void * jresult ;
13349   Dali::Matrix3 *result = 0 ;
13350
13351   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13352   jresult = (void *)result;
13353   return jresult;
13354 }
13355
13356
13357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13358   void * jresult ;
13359   Dali::Matrix3 *result = 0 ;
13360
13361   {
13362     try {
13363       result = (Dali::Matrix3 *)new Dali::Matrix3();
13364     } catch (std::out_of_range& e) {
13365       {
13366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13367       };
13368     } catch (std::exception& e) {
13369       {
13370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13371       };
13372     } catch (Dali::DaliException e) {
13373       {
13374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13375       };
13376     } catch (...) {
13377       {
13378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13379       };
13380     }
13381   }
13382
13383   jresult = (void *)result;
13384   return jresult;
13385 }
13386
13387
13388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13389   void * jresult ;
13390   Dali::Matrix3 *arg1 = 0 ;
13391   Dali::Matrix3 *result = 0 ;
13392
13393   arg1 = (Dali::Matrix3 *)jarg1;
13394   if (!arg1) {
13395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13396     return 0;
13397   }
13398   {
13399     try {
13400       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13401     } catch (std::out_of_range& e) {
13402       {
13403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13404       };
13405     } catch (std::exception& e) {
13406       {
13407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13408       };
13409     } catch (Dali::DaliException e) {
13410       {
13411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13412       };
13413     } catch (...) {
13414       {
13415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13416       };
13417     }
13418   }
13419
13420   jresult = (void *)result;
13421   return jresult;
13422 }
13423
13424
13425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13426   void * jresult ;
13427   Dali::Matrix *arg1 = 0 ;
13428   Dali::Matrix3 *result = 0 ;
13429
13430   arg1 = (Dali::Matrix *)jarg1;
13431   if (!arg1) {
13432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13433     return 0;
13434   }
13435   {
13436     try {
13437       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13438     } catch (std::out_of_range& e) {
13439       {
13440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13441       };
13442     } catch (std::exception& e) {
13443       {
13444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13445       };
13446     } catch (Dali::DaliException e) {
13447       {
13448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13449       };
13450     } catch (...) {
13451       {
13452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13453       };
13454     }
13455   }
13456
13457   jresult = (void *)result;
13458   return jresult;
13459 }
13460
13461
13462 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) {
13463   void * jresult ;
13464   float arg1 ;
13465   float arg2 ;
13466   float arg3 ;
13467   float arg4 ;
13468   float arg5 ;
13469   float arg6 ;
13470   float arg7 ;
13471   float arg8 ;
13472   float arg9 ;
13473   Dali::Matrix3 *result = 0 ;
13474
13475   arg1 = (float)jarg1;
13476   arg2 = (float)jarg2;
13477   arg3 = (float)jarg3;
13478   arg4 = (float)jarg4;
13479   arg5 = (float)jarg5;
13480   arg6 = (float)jarg6;
13481   arg7 = (float)jarg7;
13482   arg8 = (float)jarg8;
13483   arg9 = (float)jarg9;
13484   {
13485     try {
13486       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13487     } catch (std::out_of_range& e) {
13488       {
13489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13490       };
13491     } catch (std::exception& e) {
13492       {
13493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13494       };
13495     } catch (Dali::DaliException e) {
13496       {
13497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13498       };
13499     } catch (...) {
13500       {
13501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13502       };
13503     }
13504   }
13505
13506   jresult = (void *)result;
13507   return jresult;
13508 }
13509
13510
13511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13512   void * jresult ;
13513   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13514   Dali::Matrix3 *arg2 = 0 ;
13515   Dali::Matrix3 *result = 0 ;
13516
13517   arg1 = (Dali::Matrix3 *)jarg1;
13518   arg2 = (Dali::Matrix3 *)jarg2;
13519   if (!arg2) {
13520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13521     return 0;
13522   }
13523   {
13524     try {
13525       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13526     } catch (std::out_of_range& e) {
13527       {
13528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13529       };
13530     } catch (std::exception& e) {
13531       {
13532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13533       };
13534     } catch (Dali::DaliException e) {
13535       {
13536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13537       };
13538     } catch (...) {
13539       {
13540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13541       };
13542     }
13543   }
13544
13545   jresult = (void *)result;
13546   return jresult;
13547 }
13548
13549
13550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13551   void * jresult ;
13552   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13553   Dali::Matrix *arg2 = 0 ;
13554   Dali::Matrix3 *result = 0 ;
13555
13556   arg1 = (Dali::Matrix3 *)jarg1;
13557   arg2 = (Dali::Matrix *)jarg2;
13558   if (!arg2) {
13559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13560     return 0;
13561   }
13562   {
13563     try {
13564       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13565     } catch (std::out_of_range& e) {
13566       {
13567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13568       };
13569     } catch (std::exception& e) {
13570       {
13571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13572       };
13573     } catch (Dali::DaliException e) {
13574       {
13575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13576       };
13577     } catch (...) {
13578       {
13579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13580       };
13581     }
13582   }
13583
13584   jresult = (void *)result;
13585   return jresult;
13586 }
13587
13588
13589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13590   unsigned int jresult ;
13591   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13592   Dali::Matrix3 *arg2 = 0 ;
13593   bool result;
13594
13595   arg1 = (Dali::Matrix3 *)jarg1;
13596   arg2 = (Dali::Matrix3 *)jarg2;
13597   if (!arg2) {
13598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13599     return 0;
13600   }
13601   {
13602     try {
13603       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13604     } catch (std::out_of_range& e) {
13605       {
13606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13607       };
13608     } catch (std::exception& e) {
13609       {
13610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13611       };
13612     } catch (Dali::DaliException e) {
13613       {
13614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13615       };
13616     } catch (...) {
13617       {
13618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13619       };
13620     }
13621   }
13622
13623   jresult = result;
13624   return jresult;
13625 }
13626
13627
13628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13629   unsigned int jresult ;
13630   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13631   Dali::Matrix3 *arg2 = 0 ;
13632   bool result;
13633
13634   arg1 = (Dali::Matrix3 *)jarg1;
13635   arg2 = (Dali::Matrix3 *)jarg2;
13636   if (!arg2) {
13637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13638     return 0;
13639   }
13640   {
13641     try {
13642       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13643     } catch (std::out_of_range& e) {
13644       {
13645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13646       };
13647     } catch (std::exception& e) {
13648       {
13649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13650       };
13651     } catch (Dali::DaliException e) {
13652       {
13653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13654       };
13655     } catch (...) {
13656       {
13657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13658       };
13659     }
13660   }
13661
13662   jresult = result;
13663   return jresult;
13664 }
13665
13666
13667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13668   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13669
13670   arg1 = (Dali::Matrix3 *)jarg1;
13671   {
13672     try {
13673       delete arg1;
13674     } catch (std::out_of_range& e) {
13675       {
13676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13677       };
13678     } catch (std::exception& e) {
13679       {
13680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13681       };
13682     } catch (Dali::DaliException e) {
13683       {
13684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13685       };
13686     } catch (...) {
13687       {
13688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13689       };
13690     }
13691   }
13692
13693 }
13694
13695
13696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13697   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13698
13699   arg1 = (Dali::Matrix3 *)jarg1;
13700   {
13701     try {
13702       (arg1)->SetIdentity();
13703     } catch (std::out_of_range& e) {
13704       {
13705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13706       };
13707     } catch (std::exception& e) {
13708       {
13709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13710       };
13711     } catch (Dali::DaliException e) {
13712       {
13713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13714       };
13715     } catch (...) {
13716       {
13717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13718       };
13719     }
13720   }
13721
13722 }
13723
13724
13725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13726   void * jresult ;
13727   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13728   float *result = 0 ;
13729
13730   arg1 = (Dali::Matrix3 *)jarg1;
13731   {
13732     try {
13733       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13734     } catch (std::out_of_range& e) {
13735       {
13736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13737       };
13738     } catch (std::exception& e) {
13739       {
13740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13741       };
13742     } catch (Dali::DaliException e) {
13743       {
13744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13745       };
13746     } catch (...) {
13747       {
13748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13749       };
13750     }
13751   }
13752
13753   jresult = (void *)result;
13754   return jresult;
13755 }
13756
13757
13758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13759   unsigned int jresult ;
13760   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13761   bool result;
13762
13763   arg1 = (Dali::Matrix3 *)jarg1;
13764   {
13765     try {
13766       result = (bool)(arg1)->Invert();
13767     } catch (std::out_of_range& e) {
13768       {
13769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13770       };
13771     } catch (std::exception& e) {
13772       {
13773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13774       };
13775     } catch (Dali::DaliException e) {
13776       {
13777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13778       };
13779     } catch (...) {
13780       {
13781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13782       };
13783     }
13784   }
13785
13786   jresult = result;
13787   return jresult;
13788 }
13789
13790
13791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13792   unsigned int jresult ;
13793   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13794   bool result;
13795
13796   arg1 = (Dali::Matrix3 *)jarg1;
13797   {
13798     try {
13799       result = (bool)(arg1)->Transpose();
13800     } catch (std::out_of_range& e) {
13801       {
13802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13803       };
13804     } catch (std::exception& e) {
13805       {
13806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13807       };
13808     } catch (Dali::DaliException e) {
13809       {
13810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13811       };
13812     } catch (...) {
13813       {
13814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13815       };
13816     }
13817   }
13818
13819   jresult = result;
13820   return jresult;
13821 }
13822
13823
13824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13825   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13826   float arg2 ;
13827
13828   arg1 = (Dali::Matrix3 *)jarg1;
13829   arg2 = (float)jarg2;
13830   {
13831     try {
13832       (arg1)->Scale(arg2);
13833     } catch (std::out_of_range& e) {
13834       {
13835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13836       };
13837     } catch (std::exception& e) {
13838       {
13839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13840       };
13841     } catch (Dali::DaliException e) {
13842       {
13843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13844       };
13845     } catch (...) {
13846       {
13847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13848       };
13849     }
13850   }
13851
13852 }
13853
13854
13855 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13856   float jresult ;
13857   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13858   float result;
13859
13860   arg1 = (Dali::Matrix3 *)jarg1;
13861   {
13862     try {
13863       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13864     } catch (std::out_of_range& e) {
13865       {
13866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13867       };
13868     } catch (std::exception& e) {
13869       {
13870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13871       };
13872     } catch (Dali::DaliException e) {
13873       {
13874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13875       };
13876     } catch (...) {
13877       {
13878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13879       };
13880     }
13881   }
13882
13883   jresult = result;
13884   return jresult;
13885 }
13886
13887
13888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13889   unsigned int jresult ;
13890   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13891   bool result;
13892
13893   arg1 = (Dali::Matrix3 *)jarg1;
13894   {
13895     try {
13896       result = (bool)(arg1)->ScaledInverseTranspose();
13897     } catch (std::out_of_range& e) {
13898       {
13899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13900       };
13901     } catch (std::exception& e) {
13902       {
13903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13904       };
13905     } catch (Dali::DaliException e) {
13906       {
13907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13908       };
13909     } catch (...) {
13910       {
13911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13912       };
13913     }
13914   }
13915
13916   jresult = result;
13917   return jresult;
13918 }
13919
13920
13921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13922   Dali::Matrix3 *arg1 = 0 ;
13923   Dali::Matrix3 *arg2 = 0 ;
13924   Dali::Matrix3 *arg3 = 0 ;
13925
13926   arg1 = (Dali::Matrix3 *)jarg1;
13927   if (!arg1) {
13928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13929     return ;
13930   }
13931   arg2 = (Dali::Matrix3 *)jarg2;
13932   if (!arg2) {
13933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13934     return ;
13935   }
13936   arg3 = (Dali::Matrix3 *)jarg3;
13937   if (!arg3) {
13938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13939     return ;
13940   }
13941   {
13942     try {
13943       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13944     } catch (std::out_of_range& e) {
13945       {
13946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13947       };
13948     } catch (std::exception& e) {
13949       {
13950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13951       };
13952     } catch (Dali::DaliException e) {
13953       {
13954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13955       };
13956     } catch (...) {
13957       {
13958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13959       };
13960     }
13961   }
13962
13963 }
13964
13965
13966 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
13967   float jresult ;
13968   float arg1 ;
13969   float arg2 ;
13970   float result;
13971
13972   arg1 = (float)jarg1;
13973   arg2 = (float)jarg2;
13974   {
13975     try {
13976       result = (float)Dali::Random::Range(arg1,arg2);
13977     } catch (std::out_of_range& e) {
13978       {
13979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13980       };
13981     } catch (std::exception& e) {
13982       {
13983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13984       };
13985     } catch (Dali::DaliException e) {
13986       {
13987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13988       };
13989     } catch (...) {
13990       {
13991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13992       };
13993     }
13994   }
13995
13996   jresult = result;
13997   return jresult;
13998 }
13999
14000
14001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14002   void * jresult ;
14003   Dali::Vector4 result;
14004
14005   {
14006     try {
14007       result = Dali::Random::Axis();
14008     } catch (std::out_of_range& e) {
14009       {
14010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14011       };
14012     } catch (std::exception& e) {
14013       {
14014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14015       };
14016     } catch (Dali::DaliException e) {
14017       {
14018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14019       };
14020     } catch (...) {
14021       {
14022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14023       };
14024     }
14025   }
14026
14027   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14028   return jresult;
14029 }
14030
14031
14032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14033   void * jresult ;
14034   Dali::AngleAxis *result = 0 ;
14035
14036   {
14037     try {
14038       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14039     } catch (std::out_of_range& e) {
14040       {
14041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14042       };
14043     } catch (std::exception& e) {
14044       {
14045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14046       };
14047     } catch (Dali::DaliException e) {
14048       {
14049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14050       };
14051     } catch (...) {
14052       {
14053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14054       };
14055     }
14056   }
14057
14058   jresult = (void *)result;
14059   return jresult;
14060 }
14061
14062
14063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14064   void * jresult ;
14065   Dali::Radian arg1 ;
14066   Dali::Vector3 *arg2 = 0 ;
14067   Dali::Radian *argp1 ;
14068   Dali::AngleAxis *result = 0 ;
14069
14070   argp1 = (Dali::Radian *)jarg1;
14071   if (!argp1) {
14072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14073     return 0;
14074   }
14075   arg1 = *argp1;
14076   arg2 = (Dali::Vector3 *)jarg2;
14077   if (!arg2) {
14078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14079     return 0;
14080   }
14081   {
14082     try {
14083       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14084     } catch (std::out_of_range& e) {
14085       {
14086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14087       };
14088     } catch (std::exception& e) {
14089       {
14090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14091       };
14092     } catch (Dali::DaliException e) {
14093       {
14094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14095       };
14096     } catch (...) {
14097       {
14098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14099       };
14100     }
14101   }
14102
14103   jresult = (void *)result;
14104   return jresult;
14105 }
14106
14107
14108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14109   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14110   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14111
14112   arg1 = (Dali::AngleAxis *)jarg1;
14113   arg2 = (Dali::Radian *)jarg2;
14114   if (arg1) (arg1)->angle = *arg2;
14115 }
14116
14117
14118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14119   void * jresult ;
14120   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14121   Dali::Radian *result = 0 ;
14122
14123   arg1 = (Dali::AngleAxis *)jarg1;
14124   result = (Dali::Radian *)& ((arg1)->angle);
14125   jresult = (void *)result;
14126   return jresult;
14127 }
14128
14129
14130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14131   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14132   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14133
14134   arg1 = (Dali::AngleAxis *)jarg1;
14135   arg2 = (Dali::Vector3 *)jarg2;
14136   if (arg1) (arg1)->axis = *arg2;
14137 }
14138
14139
14140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14141   void * jresult ;
14142   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14143   Dali::Vector3 *result = 0 ;
14144
14145   arg1 = (Dali::AngleAxis *)jarg1;
14146   result = (Dali::Vector3 *)& ((arg1)->axis);
14147   jresult = (void *)result;
14148   return jresult;
14149 }
14150
14151
14152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14153   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14154
14155   arg1 = (Dali::AngleAxis *)jarg1;
14156   {
14157     try {
14158       delete arg1;
14159     } catch (std::out_of_range& e) {
14160       {
14161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14162       };
14163     } catch (std::exception& e) {
14164       {
14165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14166       };
14167     } catch (Dali::DaliException e) {
14168       {
14169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14170       };
14171     } catch (...) {
14172       {
14173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14174       };
14175     }
14176   }
14177
14178 }
14179
14180
14181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14182   unsigned int jresult ;
14183   Dali::AngleAxis *arg1 = 0 ;
14184   Dali::AngleAxis *arg2 = 0 ;
14185   bool result;
14186
14187   arg1 = (Dali::AngleAxis *)jarg1;
14188   if (!arg1) {
14189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14190     return 0;
14191   }
14192   arg2 = (Dali::AngleAxis *)jarg2;
14193   if (!arg2) {
14194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14195     return 0;
14196   }
14197   {
14198     try {
14199       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14200     } catch (std::out_of_range& e) {
14201       {
14202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14203       };
14204     } catch (std::exception& e) {
14205       {
14206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14207       };
14208     } catch (Dali::DaliException e) {
14209       {
14210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14211       };
14212     } catch (...) {
14213       {
14214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14215       };
14216     }
14217   }
14218
14219   jresult = result;
14220   return jresult;
14221 }
14222
14223
14224 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14225   unsigned int jresult ;
14226   unsigned int arg1 ;
14227   unsigned int result;
14228
14229   arg1 = (unsigned int)jarg1;
14230   {
14231     try {
14232       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14233     } catch (std::out_of_range& e) {
14234       {
14235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14236       };
14237     } catch (std::exception& e) {
14238       {
14239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14240       };
14241     } catch (Dali::DaliException e) {
14242       {
14243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14244       };
14245     } catch (...) {
14246       {
14247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14248       };
14249     }
14250   }
14251
14252   jresult = result;
14253   return jresult;
14254 }
14255
14256
14257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14258   unsigned int jresult ;
14259   unsigned int arg1 ;
14260   bool result;
14261
14262   arg1 = (unsigned int)jarg1;
14263   {
14264     try {
14265       result = (bool)Dali::IsPowerOfTwo(arg1);
14266     } catch (std::out_of_range& e) {
14267       {
14268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14269       };
14270     } catch (std::exception& e) {
14271       {
14272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14273       };
14274     } catch (Dali::DaliException e) {
14275       {
14276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14277       };
14278     } catch (...) {
14279       {
14280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14281       };
14282     }
14283   }
14284
14285   jresult = result;
14286   return jresult;
14287 }
14288
14289
14290 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14291   float jresult ;
14292   float arg1 ;
14293   float arg2 ;
14294   float result;
14295
14296   arg1 = (float)jarg1;
14297   arg2 = (float)jarg2;
14298   {
14299     try {
14300       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14301     } catch (std::out_of_range& e) {
14302       {
14303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14304       };
14305     } catch (std::exception& e) {
14306       {
14307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14308       };
14309     } catch (Dali::DaliException e) {
14310       {
14311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14312       };
14313     } catch (...) {
14314       {
14315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14316       };
14317     }
14318   }
14319
14320   jresult = result;
14321   return jresult;
14322 }
14323
14324
14325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14326   unsigned int jresult ;
14327   float arg1 ;
14328   bool result;
14329
14330   arg1 = (float)jarg1;
14331   {
14332     try {
14333       result = (bool)Dali::EqualsZero(arg1);
14334     } catch (std::out_of_range& e) {
14335       {
14336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14337       };
14338     } catch (std::exception& e) {
14339       {
14340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14341       };
14342     } catch (Dali::DaliException e) {
14343       {
14344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14345       };
14346     } catch (...) {
14347       {
14348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14349       };
14350     }
14351   }
14352
14353   jresult = result;
14354   return jresult;
14355 }
14356
14357
14358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14359   unsigned int jresult ;
14360   float arg1 ;
14361   float arg2 ;
14362   bool result;
14363
14364   arg1 = (float)jarg1;
14365   arg2 = (float)jarg2;
14366   {
14367     try {
14368       result = (bool)Dali::Equals(arg1,arg2);
14369     } catch (std::out_of_range& e) {
14370       {
14371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14372       };
14373     } catch (std::exception& e) {
14374       {
14375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14376       };
14377     } catch (Dali::DaliException e) {
14378       {
14379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14380       };
14381     } catch (...) {
14382       {
14383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14384       };
14385     }
14386   }
14387
14388   jresult = result;
14389   return jresult;
14390 }
14391
14392
14393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14394   unsigned int jresult ;
14395   float arg1 ;
14396   float arg2 ;
14397   float arg3 ;
14398   bool result;
14399
14400   arg1 = (float)jarg1;
14401   arg2 = (float)jarg2;
14402   arg3 = (float)jarg3;
14403   {
14404     try {
14405       result = (bool)Dali::Equals(arg1,arg2,arg3);
14406     } catch (std::out_of_range& e) {
14407       {
14408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14409       };
14410     } catch (std::exception& e) {
14411       {
14412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14413       };
14414     } catch (Dali::DaliException e) {
14415       {
14416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14417       };
14418     } catch (...) {
14419       {
14420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14421       };
14422     }
14423   }
14424
14425   jresult = result;
14426   return jresult;
14427 }
14428
14429
14430 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14431   float jresult ;
14432   float arg1 ;
14433   int arg2 ;
14434   float result;
14435
14436   arg1 = (float)jarg1;
14437   arg2 = (int)jarg2;
14438   {
14439     try {
14440       result = (float)Dali::Round(arg1,arg2);
14441     } catch (std::out_of_range& e) {
14442       {
14443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14444       };
14445     } catch (std::exception& e) {
14446       {
14447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14448       };
14449     } catch (Dali::DaliException e) {
14450       {
14451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14452       };
14453     } catch (...) {
14454       {
14455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14456       };
14457     }
14458   }
14459
14460   jresult = result;
14461   return jresult;
14462 }
14463
14464
14465 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14466   float jresult ;
14467   float arg1 ;
14468   float arg2 ;
14469   float arg3 ;
14470   float result;
14471
14472   arg1 = (float)jarg1;
14473   arg2 = (float)jarg2;
14474   arg3 = (float)jarg3;
14475   {
14476     try {
14477       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14478     } catch (std::out_of_range& e) {
14479       {
14480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14481       };
14482     } catch (std::exception& e) {
14483       {
14484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14485       };
14486     } catch (Dali::DaliException e) {
14487       {
14488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14489       };
14490     } catch (...) {
14491       {
14492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14493       };
14494     }
14495   }
14496
14497   jresult = result;
14498   return jresult;
14499 }
14500
14501
14502 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14503   float jresult ;
14504   float arg1 ;
14505   float arg2 ;
14506   float arg3 ;
14507   float arg4 ;
14508   float result;
14509
14510   arg1 = (float)jarg1;
14511   arg2 = (float)jarg2;
14512   arg3 = (float)jarg3;
14513   arg4 = (float)jarg4;
14514   {
14515     try {
14516       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14517     } catch (std::out_of_range& e) {
14518       {
14519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14520       };
14521     } catch (std::exception& e) {
14522       {
14523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14524       };
14525     } catch (Dali::DaliException e) {
14526       {
14527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14528       };
14529     } catch (...) {
14530       {
14531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14532       };
14533     }
14534   }
14535
14536   jresult = result;
14537   return jresult;
14538 }
14539
14540
14541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14542   int jresult ;
14543   int result;
14544
14545   result = (int)(int)Dali::Property::INVALID_INDEX;
14546   jresult = result;
14547   return jresult;
14548 }
14549
14550
14551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14552   int jresult ;
14553   int result;
14554
14555   result = (int)(int)Dali::Property::INVALID_KEY;
14556   jresult = result;
14557   return jresult;
14558 }
14559
14560
14561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14562   int jresult ;
14563   int result;
14564
14565   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14566   jresult = result;
14567   return jresult;
14568 }
14569
14570
14571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14572   void * jresult ;
14573   Dali::Handle *arg1 = 0 ;
14574   Dali::Property::Index arg2 ;
14575   Dali::Property *result = 0 ;
14576
14577   arg1 = (Dali::Handle *)jarg1;
14578   if (!arg1) {
14579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14580     return 0;
14581   }
14582   arg2 = (Dali::Property::Index)jarg2;
14583   {
14584     try {
14585       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14586     } catch (std::out_of_range& e) {
14587       {
14588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14589       };
14590     } catch (std::exception& e) {
14591       {
14592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14593       };
14594     } catch (Dali::DaliException e) {
14595       {
14596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14597       };
14598     } catch (...) {
14599       {
14600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14601       };
14602     }
14603   }
14604
14605   jresult = (void *)result;
14606   return jresult;
14607 }
14608
14609
14610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14611   void * jresult ;
14612   Dali::Handle *arg1 = 0 ;
14613   Dali::Property::Index arg2 ;
14614   int arg3 ;
14615   Dali::Property *result = 0 ;
14616
14617   arg1 = (Dali::Handle *)jarg1;
14618   if (!arg1) {
14619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14620     return 0;
14621   }
14622   arg2 = (Dali::Property::Index)jarg2;
14623   arg3 = (int)jarg3;
14624   {
14625     try {
14626       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14627     } catch (std::out_of_range& e) {
14628       {
14629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14630       };
14631     } catch (std::exception& e) {
14632       {
14633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14634       };
14635     } catch (Dali::DaliException e) {
14636       {
14637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14638       };
14639     } catch (...) {
14640       {
14641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14642       };
14643     }
14644   }
14645
14646   jresult = (void *)result;
14647   return jresult;
14648 }
14649
14650
14651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14652   void * jresult ;
14653   Dali::Handle *arg1 = 0 ;
14654   std::string *arg2 = 0 ;
14655   Dali::Property *result = 0 ;
14656
14657   arg1 = (Dali::Handle *)jarg1;
14658   if (!arg1) {
14659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14660     return 0;
14661   }
14662   if (!jarg2) {
14663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14664     return 0;
14665   }
14666   std::string arg2_str(jarg2);
14667   arg2 = &arg2_str;
14668   {
14669     try {
14670       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14671     } catch (std::out_of_range& e) {
14672       {
14673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14674       };
14675     } catch (std::exception& e) {
14676       {
14677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14678       };
14679     } catch (Dali::DaliException e) {
14680       {
14681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14682       };
14683     } catch (...) {
14684       {
14685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14686       };
14687     }
14688   }
14689
14690   jresult = (void *)result;
14691
14692   //argout typemap for const std::string&
14693
14694   return jresult;
14695 }
14696
14697
14698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14699   void * jresult ;
14700   Dali::Handle *arg1 = 0 ;
14701   std::string *arg2 = 0 ;
14702   int arg3 ;
14703   Dali::Property *result = 0 ;
14704
14705   arg1 = (Dali::Handle *)jarg1;
14706   if (!arg1) {
14707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14708     return 0;
14709   }
14710   if (!jarg2) {
14711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14712     return 0;
14713   }
14714   std::string arg2_str(jarg2);
14715   arg2 = &arg2_str;
14716   arg3 = (int)jarg3;
14717   {
14718     try {
14719       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14720     } catch (std::out_of_range& e) {
14721       {
14722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14723       };
14724     } catch (std::exception& e) {
14725       {
14726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14727       };
14728     } catch (Dali::DaliException e) {
14729       {
14730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14731       };
14732     } catch (...) {
14733       {
14734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14735       };
14736     }
14737   }
14738
14739   jresult = (void *)result;
14740
14741   //argout typemap for const std::string&
14742
14743   return jresult;
14744 }
14745
14746
14747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14748   Dali::Property *arg1 = (Dali::Property *) 0 ;
14749
14750   arg1 = (Dali::Property *)jarg1;
14751   {
14752     try {
14753       delete arg1;
14754     } catch (std::out_of_range& e) {
14755       {
14756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14757       };
14758     } catch (std::exception& e) {
14759       {
14760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14761       };
14762     } catch (Dali::DaliException e) {
14763       {
14764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14765       };
14766     } catch (...) {
14767       {
14768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14769       };
14770     }
14771   }
14772
14773 }
14774
14775
14776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14777   Dali::Property *arg1 = (Dali::Property *) 0 ;
14778   Dali::Handle *arg2 = 0 ;
14779
14780   arg1 = (Dali::Property *)jarg1;
14781   arg2 = (Dali::Handle *)jarg2;
14782   if (!arg2) {
14783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14784     return ;
14785   }
14786   if (arg1) (arg1)->object = *arg2;
14787 }
14788
14789
14790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14791   void * jresult ;
14792   Dali::Property *arg1 = (Dali::Property *) 0 ;
14793   Dali::Handle *result = 0 ;
14794
14795   arg1 = (Dali::Property *)jarg1;
14796   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14797   jresult = (void *)result;
14798   return jresult;
14799 }
14800
14801
14802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14803   Dali::Property *arg1 = (Dali::Property *) 0 ;
14804   Dali::Property::Index arg2 ;
14805
14806   arg1 = (Dali::Property *)jarg1;
14807   arg2 = (Dali::Property::Index)jarg2;
14808   if (arg1) (arg1)->propertyIndex = arg2;
14809 }
14810
14811
14812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14813   int jresult ;
14814   Dali::Property *arg1 = (Dali::Property *) 0 ;
14815   Dali::Property::Index result;
14816
14817   arg1 = (Dali::Property *)jarg1;
14818   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14819   jresult = result;
14820   return jresult;
14821 }
14822
14823
14824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14825   Dali::Property *arg1 = (Dali::Property *) 0 ;
14826   int arg2 ;
14827
14828   arg1 = (Dali::Property *)jarg1;
14829   arg2 = (int)jarg2;
14830   if (arg1) (arg1)->componentIndex = arg2;
14831 }
14832
14833
14834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14835   int jresult ;
14836   Dali::Property *arg1 = (Dali::Property *) 0 ;
14837   int result;
14838
14839   arg1 = (Dali::Property *)jarg1;
14840   result = (int) ((arg1)->componentIndex);
14841   jresult = result;
14842   return jresult;
14843 }
14844
14845
14846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14847   void * jresult ;
14848   Dali::Property::Array *result = 0 ;
14849
14850   {
14851     try {
14852       result = (Dali::Property::Array *)new Dali::Property::Array();
14853     } catch (std::out_of_range& e) {
14854       {
14855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14856       };
14857     } catch (std::exception& e) {
14858       {
14859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14860       };
14861     } catch (Dali::DaliException e) {
14862       {
14863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14864       };
14865     } catch (...) {
14866       {
14867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14868       };
14869     }
14870   }
14871
14872   jresult = (void *)result;
14873   return jresult;
14874 }
14875
14876
14877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14878   void * jresult ;
14879   Dali::Property::Array *arg1 = 0 ;
14880   Dali::Property::Array *result = 0 ;
14881
14882   arg1 = (Dali::Property::Array *)jarg1;
14883   if (!arg1) {
14884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14885     return 0;
14886   }
14887   {
14888     try {
14889       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14890     } catch (std::out_of_range& e) {
14891       {
14892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14893       };
14894     } catch (std::exception& e) {
14895       {
14896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14897       };
14898     } catch (Dali::DaliException e) {
14899       {
14900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14901       };
14902     } catch (...) {
14903       {
14904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14905       };
14906     }
14907   }
14908
14909   jresult = (void *)result;
14910   return jresult;
14911 }
14912
14913
14914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14915   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14916
14917   arg1 = (Dali::Property::Array *)jarg1;
14918   {
14919     try {
14920       delete arg1;
14921     } catch (std::out_of_range& e) {
14922       {
14923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14924       };
14925     } catch (std::exception& e) {
14926       {
14927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14928       };
14929     } catch (Dali::DaliException e) {
14930       {
14931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14932       };
14933     } catch (...) {
14934       {
14935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14936       };
14937     }
14938   }
14939
14940 }
14941
14942
14943 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14944   unsigned long jresult ;
14945   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14946   Dali::Property::Array::SizeType result;
14947
14948   arg1 = (Dali::Property::Array *)jarg1;
14949   {
14950     try {
14951       result = ((Dali::Property::Array const *)arg1)->Size();
14952     } catch (std::out_of_range& e) {
14953       {
14954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14955       };
14956     } catch (std::exception& e) {
14957       {
14958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14959       };
14960     } catch (Dali::DaliException e) {
14961       {
14962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14963       };
14964     } catch (...) {
14965       {
14966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14967       };
14968     }
14969   }
14970
14971   jresult = (unsigned long)result;
14972   return jresult;
14973 }
14974
14975
14976 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
14977   unsigned long jresult ;
14978   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14979   Dali::Property::Array::SizeType result;
14980
14981   arg1 = (Dali::Property::Array *)jarg1;
14982   {
14983     try {
14984       result = ((Dali::Property::Array const *)arg1)->Count();
14985     } catch (std::out_of_range& e) {
14986       {
14987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14988       };
14989     } catch (std::exception& e) {
14990       {
14991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14992       };
14993     } catch (Dali::DaliException e) {
14994       {
14995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14996       };
14997     } catch (...) {
14998       {
14999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15000       };
15001     }
15002   }
15003
15004   jresult = (unsigned long)result;
15005   return jresult;
15006 }
15007
15008
15009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15010   unsigned int jresult ;
15011   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15012   bool result;
15013
15014   arg1 = (Dali::Property::Array *)jarg1;
15015   {
15016     try {
15017       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15018     } catch (std::out_of_range& e) {
15019       {
15020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15021       };
15022     } catch (std::exception& e) {
15023       {
15024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15025       };
15026     } catch (Dali::DaliException e) {
15027       {
15028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15029       };
15030     } catch (...) {
15031       {
15032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15033       };
15034     }
15035   }
15036
15037   jresult = result;
15038   return jresult;
15039 }
15040
15041
15042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15043   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15044
15045   arg1 = (Dali::Property::Array *)jarg1;
15046   {
15047     try {
15048       (arg1)->Clear();
15049     } catch (std::out_of_range& e) {
15050       {
15051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15052       };
15053     } catch (std::exception& e) {
15054       {
15055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15056       };
15057     } catch (Dali::DaliException e) {
15058       {
15059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15060       };
15061     } catch (...) {
15062       {
15063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15064       };
15065     }
15066   }
15067
15068 }
15069
15070
15071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15072   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15073   Dali::Property::Array::SizeType arg2 ;
15074
15075   arg1 = (Dali::Property::Array *)jarg1;
15076   arg2 = (Dali::Property::Array::SizeType)jarg2;
15077   {
15078     try {
15079       (arg1)->Reserve(arg2);
15080     } catch (std::out_of_range& e) {
15081       {
15082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15083       };
15084     } catch (std::exception& e) {
15085       {
15086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15087       };
15088     } catch (Dali::DaliException e) {
15089       {
15090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15091       };
15092     } catch (...) {
15093       {
15094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15095       };
15096     }
15097   }
15098
15099 }
15100
15101
15102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15103   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15104   Dali::Property::Array::SizeType arg2 ;
15105
15106   arg1 = (Dali::Property::Array *)jarg1;
15107   arg2 = (Dali::Property::Array::SizeType)jarg2;
15108   {
15109     try {
15110       (arg1)->Resize(arg2);
15111     } catch (std::out_of_range& e) {
15112       {
15113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15114       };
15115     } catch (std::exception& e) {
15116       {
15117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15118       };
15119     } catch (Dali::DaliException e) {
15120       {
15121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15122       };
15123     } catch (...) {
15124       {
15125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15126       };
15127     }
15128   }
15129
15130 }
15131
15132
15133 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15134   unsigned long jresult ;
15135   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15136   Dali::Property::Array::SizeType result;
15137
15138   arg1 = (Dali::Property::Array *)jarg1;
15139   {
15140     try {
15141       result = (arg1)->Capacity();
15142     } catch (std::out_of_range& e) {
15143       {
15144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15145       };
15146     } catch (std::exception& e) {
15147       {
15148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15149       };
15150     } catch (Dali::DaliException e) {
15151       {
15152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15153       };
15154     } catch (...) {
15155       {
15156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15157       };
15158     }
15159   }
15160
15161   jresult = (unsigned long)result;
15162   return jresult;
15163 }
15164
15165
15166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15167   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15168   Dali::Property::Value *arg2 = 0 ;
15169
15170   arg1 = (Dali::Property::Array *)jarg1;
15171   arg2 = (Dali::Property::Value *)jarg2;
15172   if (!arg2) {
15173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15174     return ;
15175   }
15176   {
15177     try {
15178       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15179     } catch (std::out_of_range& e) {
15180       {
15181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15182       };
15183     } catch (std::exception& e) {
15184       {
15185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15186       };
15187     } catch (Dali::DaliException e) {
15188       {
15189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15190       };
15191     } catch (...) {
15192       {
15193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15194       };
15195     }
15196   }
15197
15198 }
15199
15200
15201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15202   void * jresult ;
15203   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15204   Dali::Property::Value *arg2 = 0 ;
15205   Dali::Property::Array *result = 0 ;
15206
15207   arg1 = (Dali::Property::Array *)jarg1;
15208   arg2 = (Dali::Property::Value *)jarg2;
15209   if (!arg2) {
15210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15211     return 0;
15212   }
15213   {
15214     try {
15215       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15216     } catch (std::out_of_range& e) {
15217       {
15218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15219       };
15220     } catch (std::exception& e) {
15221       {
15222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15223       };
15224     } catch (Dali::DaliException e) {
15225       {
15226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15227       };
15228     } catch (...) {
15229       {
15230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15231       };
15232     }
15233   }
15234
15235   jresult = (void *)result;
15236   return jresult;
15237 }
15238
15239
15240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15241   void * jresult ;
15242   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15243   Dali::Property::Array::SizeType arg2 ;
15244   Dali::Property::Value *result = 0 ;
15245
15246   arg1 = (Dali::Property::Array *)jarg1;
15247   arg2 = (Dali::Property::Array::SizeType)jarg2;
15248   {
15249     try {
15250       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15251     } catch (std::out_of_range& e) {
15252       {
15253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15254       };
15255     } catch (std::exception& e) {
15256       {
15257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15258       };
15259     } catch (Dali::DaliException e) {
15260       {
15261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15262       };
15263     } catch (...) {
15264       {
15265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15266       };
15267     }
15268   }
15269
15270   jresult = (void *)result;
15271   return jresult;
15272 }
15273
15274
15275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15276   void * jresult ;
15277   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15278   Dali::Property::Array::SizeType arg2 ;
15279   Dali::Property::Value *result = 0 ;
15280
15281   arg1 = (Dali::Property::Array *)jarg1;
15282   arg2 = (Dali::Property::Array::SizeType)jarg2;
15283   {
15284     try {
15285       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15286     } catch (std::out_of_range& e) {
15287       {
15288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15289       };
15290     } catch (std::exception& e) {
15291       {
15292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15293       };
15294     } catch (Dali::DaliException e) {
15295       {
15296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15297       };
15298     } catch (...) {
15299       {
15300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15301       };
15302     }
15303   }
15304
15305   jresult = (void *)result;
15306   return jresult;
15307 }
15308
15309
15310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15311   void * jresult ;
15312   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15313   Dali::Property::Array *arg2 = 0 ;
15314   Dali::Property::Array *result = 0 ;
15315
15316   arg1 = (Dali::Property::Array *)jarg1;
15317   arg2 = (Dali::Property::Array *)jarg2;
15318   if (!arg2) {
15319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15320     return 0;
15321   }
15322   {
15323     try {
15324       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15325     } catch (std::out_of_range& e) {
15326       {
15327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15328       };
15329     } catch (std::exception& e) {
15330       {
15331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15332       };
15333     } catch (Dali::DaliException e) {
15334       {
15335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15336       };
15337     } catch (...) {
15338       {
15339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15340       };
15341     }
15342   }
15343
15344   jresult = (void *)result;
15345   return jresult;
15346 }
15347
15348
15349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15350   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15351   enum Dali::Property::Key::Type arg2 ;
15352
15353   arg1 = (Dali::Property::Key *)jarg1;
15354   arg2 = (enum Dali::Property::Key::Type)jarg2;
15355   if (arg1) (arg1)->type = arg2;
15356 }
15357
15358
15359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15360   int jresult ;
15361   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15362   enum Dali::Property::Key::Type result;
15363
15364   arg1 = (Dali::Property::Key *)jarg1;
15365   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15366   jresult = (int)result;
15367   return jresult;
15368 }
15369
15370
15371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15372   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15373   Dali::Property::Index arg2 ;
15374
15375   arg1 = (Dali::Property::Key *)jarg1;
15376   arg2 = (Dali::Property::Index)jarg2;
15377   if (arg1) (arg1)->indexKey = arg2;
15378 }
15379
15380
15381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15382   int jresult ;
15383   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15384   Dali::Property::Index result;
15385
15386   arg1 = (Dali::Property::Key *)jarg1;
15387   result = (Dali::Property::Index) ((arg1)->indexKey);
15388   jresult = result;
15389   return jresult;
15390 }
15391
15392
15393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15394   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15395   std::string *arg2 = 0 ;
15396
15397   arg1 = (Dali::Property::Key *)jarg1;
15398   if (!jarg2) {
15399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15400     return ;
15401   }
15402   std::string arg2_str(jarg2);
15403   arg2 = &arg2_str;
15404   if (arg1) (arg1)->stringKey = *arg2;
15405
15406   //argout typemap for const std::string&
15407
15408 }
15409
15410
15411 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15412   char * jresult ;
15413   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15414   std::string *result = 0 ;
15415
15416   arg1 = (Dali::Property::Key *)jarg1;
15417   result = (std::string *) & ((arg1)->stringKey);
15418   jresult = SWIG_csharp_string_callback(result->c_str());
15419   return jresult;
15420 }
15421
15422
15423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15424   void * jresult ;
15425   std::string *arg1 = 0 ;
15426   Dali::Property::Key *result = 0 ;
15427
15428   if (!jarg1) {
15429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15430     return 0;
15431   }
15432   std::string arg1_str(jarg1);
15433   arg1 = &arg1_str;
15434   {
15435     try {
15436       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15437     } catch (std::out_of_range& e) {
15438       {
15439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15440       };
15441     } catch (std::exception& e) {
15442       {
15443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15444       };
15445     } catch (Dali::DaliException e) {
15446       {
15447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15448       };
15449     } catch (...) {
15450       {
15451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15452       };
15453     }
15454   }
15455
15456   jresult = (void *)result;
15457
15458   //argout typemap for const std::string&
15459
15460   return jresult;
15461 }
15462
15463
15464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15465   void * jresult ;
15466   Dali::Property::Index arg1 ;
15467   Dali::Property::Key *result = 0 ;
15468
15469   arg1 = (Dali::Property::Index)jarg1;
15470   {
15471     try {
15472       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15473     } catch (std::out_of_range& e) {
15474       {
15475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15476       };
15477     } catch (std::exception& e) {
15478       {
15479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15480       };
15481     } catch (Dali::DaliException e) {
15482       {
15483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15484       };
15485     } catch (...) {
15486       {
15487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15488       };
15489     }
15490   }
15491
15492   jresult = (void *)result;
15493   return jresult;
15494 }
15495
15496
15497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15498   unsigned int jresult ;
15499   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15500   std::string *arg2 = 0 ;
15501   bool result;
15502
15503   arg1 = (Dali::Property::Key *)jarg1;
15504   if (!jarg2) {
15505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15506     return 0;
15507   }
15508   std::string arg2_str(jarg2);
15509   arg2 = &arg2_str;
15510   {
15511     try {
15512       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15513     } catch (std::out_of_range& e) {
15514       {
15515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15516       };
15517     } catch (std::exception& e) {
15518       {
15519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15520       };
15521     } catch (Dali::DaliException e) {
15522       {
15523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15524       };
15525     } catch (...) {
15526       {
15527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15528       };
15529     }
15530   }
15531
15532   jresult = result;
15533
15534   //argout typemap for const std::string&
15535
15536   return jresult;
15537 }
15538
15539
15540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15541   unsigned int jresult ;
15542   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15543   Dali::Property::Index arg2 ;
15544   bool result;
15545
15546   arg1 = (Dali::Property::Key *)jarg1;
15547   arg2 = (Dali::Property::Index)jarg2;
15548   {
15549     try {
15550       result = (bool)(arg1)->operator ==(arg2);
15551     } catch (std::out_of_range& e) {
15552       {
15553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15554       };
15555     } catch (std::exception& e) {
15556       {
15557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15558       };
15559     } catch (Dali::DaliException e) {
15560       {
15561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15562       };
15563     } catch (...) {
15564       {
15565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15566       };
15567     }
15568   }
15569
15570   jresult = result;
15571   return jresult;
15572 }
15573
15574
15575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15576   unsigned int jresult ;
15577   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15578   Dali::Property::Key *arg2 = 0 ;
15579   bool result;
15580
15581   arg1 = (Dali::Property::Key *)jarg1;
15582   arg2 = (Dali::Property::Key *)jarg2;
15583   if (!arg2) {
15584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15585     return 0;
15586   }
15587   {
15588     try {
15589       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15590     } catch (std::out_of_range& e) {
15591       {
15592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15593       };
15594     } catch (std::exception& e) {
15595       {
15596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15597       };
15598     } catch (Dali::DaliException e) {
15599       {
15600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15601       };
15602     } catch (...) {
15603       {
15604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15605       };
15606     }
15607   }
15608
15609   jresult = result;
15610   return jresult;
15611 }
15612
15613
15614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15615   unsigned int jresult ;
15616   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15617   std::string *arg2 = 0 ;
15618   bool result;
15619
15620   arg1 = (Dali::Property::Key *)jarg1;
15621   if (!jarg2) {
15622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15623     return 0;
15624   }
15625   std::string arg2_str(jarg2);
15626   arg2 = &arg2_str;
15627   {
15628     try {
15629       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15630     } catch (std::out_of_range& e) {
15631       {
15632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15633       };
15634     } catch (std::exception& e) {
15635       {
15636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15637       };
15638     } catch (Dali::DaliException e) {
15639       {
15640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15641       };
15642     } catch (...) {
15643       {
15644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15645       };
15646     }
15647   }
15648
15649   jresult = result;
15650
15651   //argout typemap for const std::string&
15652
15653   return jresult;
15654 }
15655
15656
15657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15658   unsigned int jresult ;
15659   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15660   Dali::Property::Index arg2 ;
15661   bool result;
15662
15663   arg1 = (Dali::Property::Key *)jarg1;
15664   arg2 = (Dali::Property::Index)jarg2;
15665   {
15666     try {
15667       result = (bool)(arg1)->operator !=(arg2);
15668     } catch (std::out_of_range& e) {
15669       {
15670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15671       };
15672     } catch (std::exception& e) {
15673       {
15674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15675       };
15676     } catch (Dali::DaliException e) {
15677       {
15678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15679       };
15680     } catch (...) {
15681       {
15682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15683       };
15684     }
15685   }
15686
15687   jresult = result;
15688   return jresult;
15689 }
15690
15691
15692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15693   unsigned int jresult ;
15694   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15695   Dali::Property::Key *arg2 = 0 ;
15696   bool result;
15697
15698   arg1 = (Dali::Property::Key *)jarg1;
15699   arg2 = (Dali::Property::Key *)jarg2;
15700   if (!arg2) {
15701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15702     return 0;
15703   }
15704   {
15705     try {
15706       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15707     } catch (std::out_of_range& e) {
15708       {
15709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15710       };
15711     } catch (std::exception& e) {
15712       {
15713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15714       };
15715     } catch (Dali::DaliException e) {
15716       {
15717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15718       };
15719     } catch (...) {
15720       {
15721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15722       };
15723     }
15724   }
15725
15726   jresult = result;
15727   return jresult;
15728 }
15729
15730
15731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15732   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15733
15734   arg1 = (Dali::Property::Key *)jarg1;
15735   {
15736     try {
15737       delete arg1;
15738     } catch (std::out_of_range& e) {
15739       {
15740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15741       };
15742     } catch (std::exception& e) {
15743       {
15744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15745       };
15746     } catch (Dali::DaliException e) {
15747       {
15748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15749       };
15750     } catch (...) {
15751       {
15752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15753       };
15754     }
15755   }
15756
15757 }
15758
15759
15760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15761   void * jresult ;
15762   Dali::Property::Map *result = 0 ;
15763
15764   {
15765     try {
15766       result = (Dali::Property::Map *)new Dali::Property::Map();
15767     } catch (std::out_of_range& e) {
15768       {
15769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15770       };
15771     } catch (std::exception& e) {
15772       {
15773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15774       };
15775     } catch (Dali::DaliException e) {
15776       {
15777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15778       };
15779     } catch (...) {
15780       {
15781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15782       };
15783     }
15784   }
15785
15786   jresult = (void *)result;
15787   return jresult;
15788 }
15789
15790
15791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15792   void * jresult ;
15793   Dali::Property::Map *arg1 = 0 ;
15794   Dali::Property::Map *result = 0 ;
15795
15796   arg1 = (Dali::Property::Map *)jarg1;
15797   if (!arg1) {
15798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15799     return 0;
15800   }
15801   {
15802     try {
15803       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15804     } catch (std::out_of_range& e) {
15805       {
15806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15807       };
15808     } catch (std::exception& e) {
15809       {
15810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15811       };
15812     } catch (Dali::DaliException e) {
15813       {
15814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15815       };
15816     } catch (...) {
15817       {
15818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15819       };
15820     }
15821   }
15822
15823   jresult = (void *)result;
15824   return jresult;
15825 }
15826
15827
15828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15829   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15830
15831   arg1 = (Dali::Property::Map *)jarg1;
15832   {
15833     try {
15834       delete arg1;
15835     } catch (std::out_of_range& e) {
15836       {
15837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15838       };
15839     } catch (std::exception& e) {
15840       {
15841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15842       };
15843     } catch (Dali::DaliException e) {
15844       {
15845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15846       };
15847     } catch (...) {
15848       {
15849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15850       };
15851     }
15852   }
15853
15854 }
15855
15856
15857 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15858   unsigned long jresult ;
15859   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15860   Dali::Property::Map::SizeType result;
15861
15862   arg1 = (Dali::Property::Map *)jarg1;
15863   {
15864     try {
15865       result = ((Dali::Property::Map const *)arg1)->Count();
15866     } catch (std::out_of_range& e) {
15867       {
15868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15869       };
15870     } catch (std::exception& e) {
15871       {
15872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15873       };
15874     } catch (Dali::DaliException e) {
15875       {
15876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15877       };
15878     } catch (...) {
15879       {
15880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15881       };
15882     }
15883   }
15884
15885   jresult = (unsigned long)result;
15886   return jresult;
15887 }
15888
15889
15890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15891   unsigned int jresult ;
15892   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15893   bool result;
15894
15895   arg1 = (Dali::Property::Map *)jarg1;
15896   {
15897     try {
15898       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15899     } catch (std::out_of_range& e) {
15900       {
15901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15902       };
15903     } catch (std::exception& e) {
15904       {
15905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15906       };
15907     } catch (Dali::DaliException e) {
15908       {
15909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15910       };
15911     } catch (...) {
15912       {
15913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15914       };
15915     }
15916   }
15917
15918   jresult = result;
15919   return jresult;
15920 }
15921
15922
15923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15924   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15925   char *arg2 = (char *) 0 ;
15926   Dali::Property::Value *arg3 = 0 ;
15927
15928   arg1 = (Dali::Property::Map *)jarg1;
15929   arg2 = (char *)jarg2;
15930   arg3 = (Dali::Property::Value *)jarg3;
15931   if (!arg3) {
15932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15933     return ;
15934   }
15935   {
15936     try {
15937       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15938     } catch (std::out_of_range& e) {
15939       {
15940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15941       };
15942     } catch (std::exception& e) {
15943       {
15944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15945       };
15946     } catch (Dali::DaliException e) {
15947       {
15948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15949       };
15950     } catch (...) {
15951       {
15952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15953       };
15954     }
15955   }
15956
15957 }
15958
15959
15960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15961   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15962   Dali::Property::Index arg2 ;
15963   Dali::Property::Value *arg3 = 0 ;
15964
15965   arg1 = (Dali::Property::Map *)jarg1;
15966   arg2 = (Dali::Property::Index)jarg2;
15967   arg3 = (Dali::Property::Value *)jarg3;
15968   if (!arg3) {
15969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15970     return ;
15971   }
15972   {
15973     try {
15974       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
15975     } catch (std::out_of_range& e) {
15976       {
15977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15978       };
15979     } catch (std::exception& e) {
15980       {
15981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15982       };
15983     } catch (Dali::DaliException e) {
15984       {
15985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15986       };
15987     } catch (...) {
15988       {
15989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15990       };
15991     }
15992   }
15993
15994 }
15995
15996
15997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15998   void * jresult ;
15999   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16000   char *arg2 = (char *) 0 ;
16001   Dali::Property::Value *arg3 = 0 ;
16002   Dali::Property::Map *result = 0 ;
16003
16004   arg1 = (Dali::Property::Map *)jarg1;
16005   arg2 = (char *)jarg2;
16006   arg3 = (Dali::Property::Value *)jarg3;
16007   if (!arg3) {
16008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16009     return 0;
16010   }
16011   {
16012     try {
16013       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16014     } catch (std::out_of_range& e) {
16015       {
16016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16017       };
16018     } catch (std::exception& e) {
16019       {
16020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16021       };
16022     } catch (Dali::DaliException e) {
16023       {
16024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16025       };
16026     } catch (...) {
16027       {
16028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16029       };
16030     }
16031   }
16032
16033   jresult = (void *)result;
16034   return jresult;
16035 }
16036
16037
16038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16039   void * jresult ;
16040   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16041   Dali::Property::Index arg2 ;
16042   Dali::Property::Value *arg3 = 0 ;
16043   Dali::Property::Map *result = 0 ;
16044
16045   arg1 = (Dali::Property::Map *)jarg1;
16046   arg2 = (Dali::Property::Index)jarg2;
16047   arg3 = (Dali::Property::Value *)jarg3;
16048   if (!arg3) {
16049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16050     return 0;
16051   }
16052   {
16053     try {
16054       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16055     } catch (std::out_of_range& e) {
16056       {
16057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16058       };
16059     } catch (std::exception& e) {
16060       {
16061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16062       };
16063     } catch (Dali::DaliException e) {
16064       {
16065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16066       };
16067     } catch (...) {
16068       {
16069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16070       };
16071     }
16072   }
16073
16074   jresult = (void *)result;
16075   return jresult;
16076 }
16077
16078
16079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16080   void * jresult ;
16081   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16082   Dali::Property::Map::SizeType arg2 ;
16083   Dali::Property::Value *result = 0 ;
16084
16085   arg1 = (Dali::Property::Map *)jarg1;
16086   arg2 = (Dali::Property::Map::SizeType)jarg2;
16087   {
16088     try {
16089       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16090     } catch (std::out_of_range& e) {
16091       {
16092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16093       };
16094     } catch (std::exception& e) {
16095       {
16096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16097       };
16098     } catch (Dali::DaliException e) {
16099       {
16100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16101       };
16102     } catch (...) {
16103       {
16104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16105       };
16106     }
16107   }
16108
16109   jresult = (void *)result;
16110   return jresult;
16111 }
16112
16113
16114 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16115   char * jresult ;
16116   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16117   Dali::Property::Map::SizeType arg2 ;
16118   std::string *result = 0 ;
16119
16120   arg1 = (Dali::Property::Map *)jarg1;
16121   arg2 = (Dali::Property::Map::SizeType)jarg2;
16122   {
16123     try {
16124       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16125     } catch (std::out_of_range& e) {
16126       {
16127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16128       };
16129     } catch (std::exception& e) {
16130       {
16131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16132       };
16133     } catch (Dali::DaliException e) {
16134       {
16135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16136       };
16137     } catch (...) {
16138       {
16139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16140       };
16141     }
16142   }
16143
16144   jresult = SWIG_csharp_string_callback(result->c_str());
16145   return jresult;
16146 }
16147
16148
16149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16150   void * jresult ;
16151   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16152   Dali::Property::Map::SizeType arg2 ;
16153   SwigValueWrapper< Dali::Property::Key > result;
16154
16155   arg1 = (Dali::Property::Map *)jarg1;
16156   arg2 = (Dali::Property::Map::SizeType)jarg2;
16157   {
16158     try {
16159       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16160     } catch (std::out_of_range& e) {
16161       {
16162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16163       };
16164     } catch (std::exception& e) {
16165       {
16166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16167       };
16168     } catch (Dali::DaliException e) {
16169       {
16170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16171       };
16172     } catch (...) {
16173       {
16174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16175       };
16176     }
16177   }
16178
16179   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16180   return jresult;
16181 }
16182
16183
16184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16185   void * jresult ;
16186   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16187   Dali::Property::Map::SizeType arg2 ;
16188   StringValuePair *result = 0 ;
16189
16190   arg1 = (Dali::Property::Map *)jarg1;
16191   arg2 = (Dali::Property::Map::SizeType)jarg2;
16192   {
16193     try {
16194       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16195     } catch (std::out_of_range& e) {
16196       {
16197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16198       };
16199     } catch (std::exception& e) {
16200       {
16201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16202       };
16203     } catch (Dali::DaliException e) {
16204       {
16205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16206       };
16207     } catch (...) {
16208       {
16209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16210       };
16211     }
16212   }
16213
16214   jresult = (void *)result;
16215   return jresult;
16216 }
16217
16218
16219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16220   void * jresult ;
16221   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16222   char *arg2 = (char *) 0 ;
16223   Dali::Property::Value *result = 0 ;
16224
16225   arg1 = (Dali::Property::Map *)jarg1;
16226   arg2 = (char *)jarg2;
16227   {
16228     try {
16229       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16230     } catch (std::out_of_range& e) {
16231       {
16232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16233       };
16234     } catch (std::exception& e) {
16235       {
16236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16237       };
16238     } catch (Dali::DaliException e) {
16239       {
16240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16241       };
16242     } catch (...) {
16243       {
16244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16245       };
16246     }
16247   }
16248
16249   jresult = (void *)result;
16250   return jresult;
16251 }
16252
16253
16254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16255   void * jresult ;
16256   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16257   Dali::Property::Index arg2 ;
16258   Dali::Property::Value *result = 0 ;
16259
16260   arg1 = (Dali::Property::Map *)jarg1;
16261   arg2 = (Dali::Property::Index)jarg2;
16262   {
16263     try {
16264       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16265     } catch (std::out_of_range& e) {
16266       {
16267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16268       };
16269     } catch (std::exception& e) {
16270       {
16271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16272       };
16273     } catch (Dali::DaliException e) {
16274       {
16275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16276       };
16277     } catch (...) {
16278       {
16279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16280       };
16281     }
16282   }
16283
16284   jresult = (void *)result;
16285   return jresult;
16286 }
16287
16288
16289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16290   void * jresult ;
16291   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16292   Dali::Property::Index arg2 ;
16293   std::string *arg3 = 0 ;
16294   Dali::Property::Value *result = 0 ;
16295
16296   arg1 = (Dali::Property::Map *)jarg1;
16297   arg2 = (Dali::Property::Index)jarg2;
16298   if (!jarg3) {
16299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16300     return 0;
16301   }
16302   std::string arg3_str(jarg3);
16303   arg3 = &arg3_str;
16304   {
16305     try {
16306       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16307     } catch (std::out_of_range& e) {
16308       {
16309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16310       };
16311     } catch (std::exception& e) {
16312       {
16313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16314       };
16315     } catch (Dali::DaliException e) {
16316       {
16317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16318       };
16319     } catch (...) {
16320       {
16321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16322       };
16323     }
16324   }
16325
16326   jresult = (void *)result;
16327
16328   //argout typemap for const std::string&
16329
16330   return jresult;
16331 }
16332
16333
16334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16335   void * jresult ;
16336   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16337   std::string *arg2 = 0 ;
16338   Dali::Property::Type arg3 ;
16339   Dali::Property::Value *result = 0 ;
16340
16341   arg1 = (Dali::Property::Map *)jarg1;
16342   if (!jarg2) {
16343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16344     return 0;
16345   }
16346   std::string arg2_str(jarg2);
16347   arg2 = &arg2_str;
16348   arg3 = (Dali::Property::Type)jarg3;
16349   {
16350     try {
16351       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16352     } catch (std::out_of_range& e) {
16353       {
16354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16355       };
16356     } catch (std::exception& e) {
16357       {
16358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16359       };
16360     } catch (Dali::DaliException e) {
16361       {
16362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16363       };
16364     } catch (...) {
16365       {
16366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16367       };
16368     }
16369   }
16370
16371   jresult = (void *)result;
16372
16373   //argout typemap for const std::string&
16374
16375   return jresult;
16376 }
16377
16378
16379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16380   void * jresult ;
16381   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16382   Dali::Property::Index arg2 ;
16383   Dali::Property::Type arg3 ;
16384   Dali::Property::Value *result = 0 ;
16385
16386   arg1 = (Dali::Property::Map *)jarg1;
16387   arg2 = (Dali::Property::Index)jarg2;
16388   arg3 = (Dali::Property::Type)jarg3;
16389   {
16390     try {
16391       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16392     } catch (std::out_of_range& e) {
16393       {
16394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16395       };
16396     } catch (std::exception& e) {
16397       {
16398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16399       };
16400     } catch (Dali::DaliException e) {
16401       {
16402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16403       };
16404     } catch (...) {
16405       {
16406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16407       };
16408     }
16409   }
16410
16411   jresult = (void *)result;
16412   return jresult;
16413 }
16414
16415
16416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16417   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16418
16419   arg1 = (Dali::Property::Map *)jarg1;
16420   {
16421     try {
16422       (arg1)->Clear();
16423     } catch (std::out_of_range& e) {
16424       {
16425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16426       };
16427     } catch (std::exception& e) {
16428       {
16429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16430       };
16431     } catch (Dali::DaliException e) {
16432       {
16433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16434       };
16435     } catch (...) {
16436       {
16437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16438       };
16439     }
16440   }
16441
16442 }
16443
16444
16445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16446   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16447   Dali::Property::Map *arg2 = 0 ;
16448
16449   arg1 = (Dali::Property::Map *)jarg1;
16450   arg2 = (Dali::Property::Map *)jarg2;
16451   if (!arg2) {
16452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16453     return ;
16454   }
16455   {
16456     try {
16457       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16458     } catch (std::out_of_range& e) {
16459       {
16460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16461       };
16462     } catch (std::exception& e) {
16463       {
16464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16465       };
16466     } catch (Dali::DaliException e) {
16467       {
16468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16469       };
16470     } catch (...) {
16471       {
16472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16473       };
16474     }
16475   }
16476
16477 }
16478
16479
16480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16481   void * jresult ;
16482   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16483   std::string *arg2 = 0 ;
16484   Dali::Property::Value *result = 0 ;
16485
16486   arg1 = (Dali::Property::Map *)jarg1;
16487   if (!jarg2) {
16488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16489     return 0;
16490   }
16491   std::string arg2_str(jarg2);
16492   arg2 = &arg2_str;
16493   {
16494     try {
16495       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16496     } catch (std::out_of_range& e) {
16497       {
16498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16499       };
16500     } catch (std::exception& e) {
16501       {
16502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16503       };
16504     } catch (Dali::DaliException e) {
16505       {
16506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16507       };
16508     } catch (...) {
16509       {
16510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16511       };
16512     }
16513   }
16514
16515   jresult = (void *)result;
16516
16517   //argout typemap for const std::string&
16518
16519   return jresult;
16520 }
16521
16522
16523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16524   void * jresult ;
16525   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16526   Dali::Property::Index arg2 ;
16527   Dali::Property::Value *result = 0 ;
16528
16529   arg1 = (Dali::Property::Map *)jarg1;
16530   arg2 = (Dali::Property::Index)jarg2;
16531   {
16532     try {
16533       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16534     } catch (std::out_of_range& e) {
16535       {
16536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16537       };
16538     } catch (std::exception& e) {
16539       {
16540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16541       };
16542     } catch (Dali::DaliException e) {
16543       {
16544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16545       };
16546     } catch (...) {
16547       {
16548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16549       };
16550     }
16551   }
16552
16553   jresult = (void *)result;
16554   return jresult;
16555 }
16556
16557
16558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16559   void * jresult ;
16560   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16561   Dali::Property::Map *arg2 = 0 ;
16562   Dali::Property::Map *result = 0 ;
16563
16564   arg1 = (Dali::Property::Map *)jarg1;
16565   arg2 = (Dali::Property::Map *)jarg2;
16566   if (!arg2) {
16567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16568     return 0;
16569   }
16570   {
16571     try {
16572       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16573     } catch (std::out_of_range& e) {
16574       {
16575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16576       };
16577     } catch (std::exception& e) {
16578       {
16579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16580       };
16581     } catch (Dali::DaliException e) {
16582       {
16583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16584       };
16585     } catch (...) {
16586       {
16587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16588       };
16589     }
16590   }
16591
16592   jresult = (void *)result;
16593   return jresult;
16594 }
16595
16596
16597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
16598
16599   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16600
16601   if (!jarg2) {
16602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16603     return;
16604   }
16605   std::string arg2_str(jarg2);
16606   std::string* arg2 = &arg2_str;
16607
16608   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16609
16610   {
16611     try {
16612       arg1->operator[]((std::string const &)*arg2) = *arg3;
16613     } catch (std::out_of_range& e) {
16614       {
16615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16616       };
16617     } catch (std::exception& e) {
16618       {
16619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16620       };
16621     } catch (Dali::DaliException e) {
16622       {
16623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16624       };
16625     } catch (...) {
16626       {
16627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16628       };
16629     }
16630   }
16631 }
16632
16633
16634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
16635
16636   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16637   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
16638   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16639
16640   {
16641     try {
16642       arg1->operator[](arg2) = *arg3;
16643     } catch (std::out_of_range& e) {
16644       {
16645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16646       };
16647     } catch (std::exception& e) {
16648       {
16649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16650       };
16651     } catch (Dali::DaliException e) {
16652       {
16653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16654       };
16655     } catch (...) {
16656       {
16657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16658       };
16659     }
16660   }
16661 }
16662
16663
16664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16665   void * jresult ;
16666   Dali::Property::Value *result = 0 ;
16667
16668   {
16669     try {
16670       result = (Dali::Property::Value *)new Dali::Property::Value();
16671     } catch (std::out_of_range& e) {
16672       {
16673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16674       };
16675     } catch (std::exception& e) {
16676       {
16677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16678       };
16679     } catch (Dali::DaliException e) {
16680       {
16681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16682       };
16683     } catch (...) {
16684       {
16685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16686       };
16687     }
16688   }
16689
16690   jresult = (void *)result;
16691   return jresult;
16692 }
16693
16694
16695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16696   void * jresult ;
16697   bool arg1 ;
16698   Dali::Property::Value *result = 0 ;
16699
16700   arg1 = jarg1 ? true : false;
16701   {
16702     try {
16703       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16704     } catch (std::out_of_range& e) {
16705       {
16706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16707       };
16708     } catch (std::exception& e) {
16709       {
16710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16711       };
16712     } catch (Dali::DaliException e) {
16713       {
16714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16715       };
16716     } catch (...) {
16717       {
16718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16719       };
16720     }
16721   }
16722
16723   jresult = (void *)result;
16724   return jresult;
16725 }
16726
16727
16728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16729   void * jresult ;
16730   int arg1 ;
16731   Dali::Property::Value *result = 0 ;
16732
16733   arg1 = (int)jarg1;
16734   {
16735     try {
16736       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16737     } catch (std::out_of_range& e) {
16738       {
16739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16740       };
16741     } catch (std::exception& e) {
16742       {
16743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16744       };
16745     } catch (Dali::DaliException e) {
16746       {
16747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16748       };
16749     } catch (...) {
16750       {
16751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16752       };
16753     }
16754   }
16755
16756   jresult = (void *)result;
16757   return jresult;
16758 }
16759
16760
16761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16762   void * jresult ;
16763   float arg1 ;
16764   Dali::Property::Value *result = 0 ;
16765
16766   arg1 = (float)jarg1;
16767   {
16768     try {
16769       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16770     } catch (std::out_of_range& e) {
16771       {
16772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16773       };
16774     } catch (std::exception& e) {
16775       {
16776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16777       };
16778     } catch (Dali::DaliException e) {
16779       {
16780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16781       };
16782     } catch (...) {
16783       {
16784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16785       };
16786     }
16787   }
16788
16789   jresult = (void *)result;
16790   return jresult;
16791 }
16792
16793
16794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16795   void * jresult ;
16796   Dali::Vector2 *arg1 = 0 ;
16797   Dali::Property::Value *result = 0 ;
16798
16799   arg1 = (Dali::Vector2 *)jarg1;
16800   if (!arg1) {
16801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16802     return 0;
16803   }
16804   {
16805     try {
16806       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16807     } catch (std::out_of_range& e) {
16808       {
16809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16810       };
16811     } catch (std::exception& e) {
16812       {
16813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16814       };
16815     } catch (Dali::DaliException e) {
16816       {
16817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16818       };
16819     } catch (...) {
16820       {
16821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16822       };
16823     }
16824   }
16825
16826   jresult = (void *)result;
16827   return jresult;
16828 }
16829
16830
16831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16832   void * jresult ;
16833   Dali::Vector3 *arg1 = 0 ;
16834   Dali::Property::Value *result = 0 ;
16835
16836   arg1 = (Dali::Vector3 *)jarg1;
16837   if (!arg1) {
16838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16839     return 0;
16840   }
16841   {
16842     try {
16843       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16844     } catch (std::out_of_range& e) {
16845       {
16846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16847       };
16848     } catch (std::exception& e) {
16849       {
16850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16851       };
16852     } catch (Dali::DaliException e) {
16853       {
16854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16855       };
16856     } catch (...) {
16857       {
16858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16859       };
16860     }
16861   }
16862
16863   jresult = (void *)result;
16864   return jresult;
16865 }
16866
16867
16868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16869   void * jresult ;
16870   Dali::Vector4 *arg1 = 0 ;
16871   Dali::Property::Value *result = 0 ;
16872
16873   arg1 = (Dali::Vector4 *)jarg1;
16874   if (!arg1) {
16875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16876     return 0;
16877   }
16878   {
16879     try {
16880       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16881     } catch (std::out_of_range& e) {
16882       {
16883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16884       };
16885     } catch (std::exception& e) {
16886       {
16887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16888       };
16889     } catch (Dali::DaliException e) {
16890       {
16891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16892       };
16893     } catch (...) {
16894       {
16895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16896       };
16897     }
16898   }
16899
16900   jresult = (void *)result;
16901   return jresult;
16902 }
16903
16904
16905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16906   void * jresult ;
16907   Dali::Matrix3 *arg1 = 0 ;
16908   Dali::Property::Value *result = 0 ;
16909
16910   arg1 = (Dali::Matrix3 *)jarg1;
16911   if (!arg1) {
16912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16913     return 0;
16914   }
16915   {
16916     try {
16917       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16918     } catch (std::out_of_range& e) {
16919       {
16920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16921       };
16922     } catch (std::exception& e) {
16923       {
16924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16925       };
16926     } catch (Dali::DaliException e) {
16927       {
16928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16929       };
16930     } catch (...) {
16931       {
16932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16933       };
16934     }
16935   }
16936
16937   jresult = (void *)result;
16938   return jresult;
16939 }
16940
16941
16942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16943   void * jresult ;
16944   Dali::Matrix *arg1 = 0 ;
16945   Dali::Property::Value *result = 0 ;
16946
16947   arg1 = (Dali::Matrix *)jarg1;
16948   if (!arg1) {
16949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16950     return 0;
16951   }
16952   {
16953     try {
16954       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16955     } catch (std::out_of_range& e) {
16956       {
16957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16958       };
16959     } catch (std::exception& e) {
16960       {
16961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16962       };
16963     } catch (Dali::DaliException e) {
16964       {
16965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16966       };
16967     } catch (...) {
16968       {
16969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16970       };
16971     }
16972   }
16973
16974   jresult = (void *)result;
16975   return jresult;
16976 }
16977
16978
16979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16980   void * jresult ;
16981   Dali::Rect< int > *arg1 = 0 ;
16982   Dali::Property::Value *result = 0 ;
16983
16984   arg1 = (Dali::Rect< int > *)jarg1;
16985   if (!arg1) {
16986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16987     return 0;
16988   }
16989   {
16990     try {
16991       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16992     } catch (std::out_of_range& e) {
16993       {
16994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16995       };
16996     } catch (std::exception& e) {
16997       {
16998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16999       };
17000     } catch (Dali::DaliException e) {
17001       {
17002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17003       };
17004     } catch (...) {
17005       {
17006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17007       };
17008     }
17009   }
17010
17011   jresult = (void *)result;
17012   return jresult;
17013 }
17014
17015
17016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17017   void * jresult ;
17018   Dali::AngleAxis *arg1 = 0 ;
17019   Dali::Property::Value *result = 0 ;
17020
17021   arg1 = (Dali::AngleAxis *)jarg1;
17022   if (!arg1) {
17023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17024     return 0;
17025   }
17026   {
17027     try {
17028       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17029     } catch (std::out_of_range& e) {
17030       {
17031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17032       };
17033     } catch (std::exception& e) {
17034       {
17035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17036       };
17037     } catch (Dali::DaliException e) {
17038       {
17039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17040       };
17041     } catch (...) {
17042       {
17043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17044       };
17045     }
17046   }
17047
17048   jresult = (void *)result;
17049   return jresult;
17050 }
17051
17052
17053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17054   void * jresult ;
17055   Dali::Quaternion *arg1 = 0 ;
17056   Dali::Property::Value *result = 0 ;
17057
17058   arg1 = (Dali::Quaternion *)jarg1;
17059   if (!arg1) {
17060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17061     return 0;
17062   }
17063   {
17064     try {
17065       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17066     } catch (std::out_of_range& e) {
17067       {
17068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17069       };
17070     } catch (std::exception& e) {
17071       {
17072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17073       };
17074     } catch (Dali::DaliException e) {
17075       {
17076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17077       };
17078     } catch (...) {
17079       {
17080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17081       };
17082     }
17083   }
17084
17085   jresult = (void *)result;
17086   return jresult;
17087 }
17088
17089
17090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17091   void * jresult ;
17092   std::string *arg1 = 0 ;
17093   Dali::Property::Value *result = 0 ;
17094
17095   if (!jarg1) {
17096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17097     return 0;
17098   }
17099   std::string arg1_str(jarg1);
17100   arg1 = &arg1_str;
17101   {
17102     try {
17103       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17104     } catch (std::out_of_range& e) {
17105       {
17106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17107       };
17108     } catch (std::exception& e) {
17109       {
17110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17111       };
17112     } catch (Dali::DaliException e) {
17113       {
17114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17115       };
17116     } catch (...) {
17117       {
17118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17119       };
17120     }
17121   }
17122
17123   jresult = (void *)result;
17124
17125   //argout typemap for const std::string&
17126
17127   return jresult;
17128 }
17129
17130
17131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17132   void * jresult ;
17133   Dali::Property::Array *arg1 = 0 ;
17134   Dali::Property::Value *result = 0 ;
17135
17136   arg1 = (Dali::Property::Array *)jarg1;
17137   if (!arg1) {
17138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17139     return 0;
17140   }
17141   {
17142     try {
17143       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17144     } catch (std::out_of_range& e) {
17145       {
17146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17147       };
17148     } catch (std::exception& e) {
17149       {
17150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17151       };
17152     } catch (Dali::DaliException e) {
17153       {
17154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17155       };
17156     } catch (...) {
17157       {
17158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17159       };
17160     }
17161   }
17162
17163   jresult = (void *)result;
17164   return jresult;
17165 }
17166
17167
17168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17169   void * jresult ;
17170   Dali::Property::Map *arg1 = 0 ;
17171   Dali::Property::Value *result = 0 ;
17172
17173   arg1 = (Dali::Property::Map *)jarg1;
17174   if (!arg1) {
17175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17176     return 0;
17177   }
17178   {
17179     try {
17180       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17181     } catch (std::out_of_range& e) {
17182       {
17183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17184       };
17185     } catch (std::exception& e) {
17186       {
17187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17188       };
17189     } catch (Dali::DaliException e) {
17190       {
17191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17192       };
17193     } catch (...) {
17194       {
17195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17196       };
17197     }
17198   }
17199
17200   jresult = (void *)result;
17201   return jresult;
17202 }
17203
17204
17205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17206   void * jresult ;
17207   Extents *arg1 = 0 ;
17208   Dali::Property::Value *result = 0 ;
17209
17210   arg1 = (Extents *)jarg1;
17211   if (!arg1) {
17212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17213     return 0;
17214   }
17215   {
17216     try {
17217       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17218     } catch (std::out_of_range& e) {
17219       {
17220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17221       };
17222     } catch (std::exception& e) {
17223       {
17224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17225       };
17226     } catch (...) {
17227       {
17228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17229       };
17230     }
17231   }
17232   jresult = (void *)result;
17233   return jresult;
17234 }
17235
17236
17237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17238   void * jresult ;
17239   Dali::Property::Type arg1 ;
17240   Dali::Property::Value *result = 0 ;
17241
17242   arg1 = (Dali::Property::Type)jarg1;
17243   {
17244     try {
17245       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17246     } catch (std::out_of_range& e) {
17247       {
17248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17249       };
17250     } catch (std::exception& e) {
17251       {
17252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17253       };
17254     } catch (Dali::DaliException e) {
17255       {
17256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17257       };
17258     } catch (...) {
17259       {
17260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17261       };
17262     }
17263   }
17264
17265   jresult = (void *)result;
17266   return jresult;
17267 }
17268
17269
17270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17271   void * jresult ;
17272   Dali::Property::Value *arg1 = 0 ;
17273   Dali::Property::Value *result = 0 ;
17274
17275   arg1 = (Dali::Property::Value *)jarg1;
17276   if (!arg1) {
17277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17278     return 0;
17279   }
17280   {
17281     try {
17282       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17283     } catch (std::out_of_range& e) {
17284       {
17285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17286       };
17287     } catch (std::exception& e) {
17288       {
17289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17290       };
17291     } catch (Dali::DaliException e) {
17292       {
17293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17294       };
17295     } catch (...) {
17296       {
17297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17298       };
17299     }
17300   }
17301
17302   jresult = (void *)result;
17303   return jresult;
17304 }
17305
17306
17307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17308   void * jresult ;
17309   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17310   Dali::Property::Value *arg2 = 0 ;
17311   Dali::Property::Value *result = 0 ;
17312
17313   arg1 = (Dali::Property::Value *)jarg1;
17314   arg2 = (Dali::Property::Value *)jarg2;
17315   if (!arg2) {
17316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17317     return 0;
17318   }
17319   {
17320     try {
17321       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17322     } catch (std::out_of_range& e) {
17323       {
17324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17325       };
17326     } catch (std::exception& e) {
17327       {
17328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17329       };
17330     } catch (Dali::DaliException e) {
17331       {
17332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17333       };
17334     } catch (...) {
17335       {
17336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17337       };
17338     }
17339   }
17340
17341   jresult = (void *)result;
17342   return jresult;
17343 }
17344
17345
17346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17347   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17348
17349   arg1 = (Dali::Property::Value *)jarg1;
17350   {
17351     try {
17352       delete arg1;
17353     } catch (std::out_of_range& e) {
17354       {
17355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17356       };
17357     } catch (std::exception& e) {
17358       {
17359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17360       };
17361     } catch (Dali::DaliException e) {
17362       {
17363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17364       };
17365     } catch (...) {
17366       {
17367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17368       };
17369     }
17370   }
17371
17372 }
17373
17374
17375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17376   int jresult ;
17377   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17378   Dali::Property::Type result;
17379
17380   arg1 = (Dali::Property::Value *)jarg1;
17381   {
17382     try {
17383       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17384     } catch (std::out_of_range& e) {
17385       {
17386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17387       };
17388     } catch (std::exception& e) {
17389       {
17390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17391       };
17392     } catch (Dali::DaliException e) {
17393       {
17394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17395       };
17396     } catch (...) {
17397       {
17398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17399       };
17400     }
17401   }
17402
17403   jresult = (int)result;
17404   return jresult;
17405 }
17406
17407
17408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17409   unsigned int jresult ;
17410   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17411   bool *arg2 = 0 ;
17412   bool result;
17413
17414   arg1 = (Dali::Property::Value *)jarg1;
17415   arg2 = (bool *)jarg2;
17416   {
17417     try {
17418       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17419     } catch (std::out_of_range& e) {
17420       {
17421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17422       };
17423     } catch (std::exception& e) {
17424       {
17425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17426       };
17427     } catch (Dali::DaliException e) {
17428       {
17429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17430       };
17431     } catch (...) {
17432       {
17433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17434       };
17435     }
17436   }
17437
17438   jresult = result;
17439   return jresult;
17440 }
17441
17442
17443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17444   unsigned int jresult ;
17445   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17446   float *arg2 = 0 ;
17447   bool result;
17448
17449   arg1 = (Dali::Property::Value *)jarg1;
17450   arg2 = (float *)jarg2;
17451   {
17452     try {
17453       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17454     } catch (std::out_of_range& e) {
17455       {
17456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17457       };
17458     } catch (std::exception& e) {
17459       {
17460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17461       };
17462     } catch (Dali::DaliException e) {
17463       {
17464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17465       };
17466     } catch (...) {
17467       {
17468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17469       };
17470     }
17471   }
17472
17473   jresult = result;
17474   return jresult;
17475 }
17476
17477
17478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17479   unsigned int jresult ;
17480   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17481   int *arg2 = 0 ;
17482   bool result;
17483
17484   arg1 = (Dali::Property::Value *)jarg1;
17485   arg2 = (int *)jarg2;
17486   {
17487     try {
17488       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17489     } catch (std::out_of_range& e) {
17490       {
17491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17492       };
17493     } catch (std::exception& e) {
17494       {
17495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17496       };
17497     } catch (Dali::DaliException e) {
17498       {
17499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17500       };
17501     } catch (...) {
17502       {
17503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17504       };
17505     }
17506   }
17507
17508   jresult = result;
17509   return jresult;
17510 }
17511
17512
17513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17514   unsigned int jresult ;
17515   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17516   Dali::Rect< int > *arg2 = 0 ;
17517   bool result;
17518
17519   arg1 = (Dali::Property::Value *)jarg1;
17520   arg2 = (Dali::Rect< int > *)jarg2;
17521   if (!arg2) {
17522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17523     return 0;
17524   }
17525   {
17526     try {
17527       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17528     } catch (std::out_of_range& e) {
17529       {
17530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17531       };
17532     } catch (std::exception& e) {
17533       {
17534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17535       };
17536     } catch (Dali::DaliException e) {
17537       {
17538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17539       };
17540     } catch (...) {
17541       {
17542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17543       };
17544     }
17545   }
17546
17547   jresult = result;
17548   return jresult;
17549 }
17550
17551
17552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17553   unsigned int jresult ;
17554   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17555   Dali::Vector2 *arg2 = 0 ;
17556   bool result;
17557
17558   arg1 = (Dali::Property::Value *)jarg1;
17559   arg2 = (Dali::Vector2 *)jarg2;
17560   if (!arg2) {
17561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17562     return 0;
17563   }
17564   {
17565     try {
17566       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17567     } catch (std::out_of_range& e) {
17568       {
17569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17570       };
17571     } catch (std::exception& e) {
17572       {
17573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17574       };
17575     } catch (Dali::DaliException e) {
17576       {
17577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17578       };
17579     } catch (...) {
17580       {
17581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17582       };
17583     }
17584   }
17585
17586   jresult = result;
17587   return jresult;
17588 }
17589
17590
17591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17592   unsigned int jresult ;
17593   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17594   Dali::Vector3 *arg2 = 0 ;
17595   bool result;
17596
17597   arg1 = (Dali::Property::Value *)jarg1;
17598   arg2 = (Dali::Vector3 *)jarg2;
17599   if (!arg2) {
17600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17601     return 0;
17602   }
17603   {
17604     try {
17605       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17606     } catch (std::out_of_range& e) {
17607       {
17608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17609       };
17610     } catch (std::exception& e) {
17611       {
17612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17613       };
17614     } catch (Dali::DaliException e) {
17615       {
17616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17617       };
17618     } catch (...) {
17619       {
17620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17621       };
17622     }
17623   }
17624
17625   jresult = result;
17626   return jresult;
17627 }
17628
17629
17630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17631   unsigned int jresult ;
17632   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17633   Dali::Vector4 *arg2 = 0 ;
17634   bool result;
17635
17636   arg1 = (Dali::Property::Value *)jarg1;
17637   arg2 = (Dali::Vector4 *)jarg2;
17638   if (!arg2) {
17639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17640     return 0;
17641   }
17642   {
17643     try {
17644       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17645     } catch (std::out_of_range& e) {
17646       {
17647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17648       };
17649     } catch (std::exception& e) {
17650       {
17651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17652       };
17653     } catch (Dali::DaliException e) {
17654       {
17655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17656       };
17657     } catch (...) {
17658       {
17659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17660       };
17661     }
17662   }
17663
17664   jresult = result;
17665   return jresult;
17666 }
17667
17668
17669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17670   unsigned int jresult ;
17671   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17672   Dali::Matrix3 *arg2 = 0 ;
17673   bool result;
17674
17675   arg1 = (Dali::Property::Value *)jarg1;
17676   arg2 = (Dali::Matrix3 *)jarg2;
17677   if (!arg2) {
17678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17679     return 0;
17680   }
17681   {
17682     try {
17683       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17684     } catch (std::out_of_range& e) {
17685       {
17686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17687       };
17688     } catch (std::exception& e) {
17689       {
17690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17691       };
17692     } catch (Dali::DaliException e) {
17693       {
17694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17695       };
17696     } catch (...) {
17697       {
17698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17699       };
17700     }
17701   }
17702
17703   jresult = result;
17704   return jresult;
17705 }
17706
17707
17708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17709   unsigned int jresult ;
17710   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17711   Dali::Matrix *arg2 = 0 ;
17712   bool result;
17713
17714   arg1 = (Dali::Property::Value *)jarg1;
17715   arg2 = (Dali::Matrix *)jarg2;
17716   if (!arg2) {
17717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17718     return 0;
17719   }
17720   {
17721     try {
17722       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17723     } catch (std::out_of_range& e) {
17724       {
17725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17726       };
17727     } catch (std::exception& e) {
17728       {
17729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17730       };
17731     } catch (Dali::DaliException e) {
17732       {
17733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17734       };
17735     } catch (...) {
17736       {
17737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17738       };
17739     }
17740   }
17741
17742   jresult = result;
17743   return jresult;
17744 }
17745
17746
17747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17748   unsigned int jresult ;
17749   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17750   Dali::AngleAxis *arg2 = 0 ;
17751   bool result;
17752
17753   arg1 = (Dali::Property::Value *)jarg1;
17754   arg2 = (Dali::AngleAxis *)jarg2;
17755   if (!arg2) {
17756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17757     return 0;
17758   }
17759   {
17760     try {
17761       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17762     } catch (std::out_of_range& e) {
17763       {
17764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17765       };
17766     } catch (std::exception& e) {
17767       {
17768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17769       };
17770     } catch (Dali::DaliException e) {
17771       {
17772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17773       };
17774     } catch (...) {
17775       {
17776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17777       };
17778     }
17779   }
17780
17781   jresult = result;
17782   return jresult;
17783 }
17784
17785
17786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17787   unsigned int jresult ;
17788   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17789   Dali::Quaternion *arg2 = 0 ;
17790   bool result;
17791
17792   arg1 = (Dali::Property::Value *)jarg1;
17793   arg2 = (Dali::Quaternion *)jarg2;
17794   if (!arg2) {
17795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17796     return 0;
17797   }
17798   {
17799     try {
17800       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17801     } catch (std::out_of_range& e) {
17802       {
17803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17804       };
17805     } catch (std::exception& e) {
17806       {
17807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17808       };
17809     } catch (Dali::DaliException e) {
17810       {
17811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17812       };
17813     } catch (...) {
17814       {
17815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17816       };
17817     }
17818   }
17819
17820   jresult = result;
17821   return jresult;
17822 }
17823
17824
17825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17826   unsigned int jresult ;
17827   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17828   std::string *arg2 = 0 ;
17829   bool result;
17830
17831   arg1 = (Dali::Property::Value *)jarg1;
17832
17833   //typemap in
17834   std::string temp;
17835   arg2 = &temp;
17836
17837   {
17838     try {
17839       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17840     } catch (std::out_of_range& e) {
17841       {
17842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17843       };
17844     } catch (std::exception& e) {
17845       {
17846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17847       };
17848     } catch (Dali::DaliException e) {
17849       {
17850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17851       };
17852     } catch (...) {
17853       {
17854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17855       };
17856     }
17857   }
17858
17859   jresult = result;
17860
17861   //Typemap argout in c++ file.
17862   //This will convert c++ string to c# string
17863   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17864
17865   return jresult;
17866 }
17867
17868
17869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17870   unsigned int jresult ;
17871   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17872   Dali::Property::Array *arg2 = 0 ;
17873   bool result;
17874
17875   arg1 = (Dali::Property::Value *)jarg1;
17876   arg2 = (Dali::Property::Array *)jarg2;
17877   if (!arg2) {
17878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17879     return 0;
17880   }
17881   {
17882     try {
17883       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17884     } catch (std::out_of_range& e) {
17885       {
17886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17887       };
17888     } catch (std::exception& e) {
17889       {
17890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17891       };
17892     } catch (Dali::DaliException e) {
17893       {
17894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17895       };
17896     } catch (...) {
17897       {
17898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17899       };
17900     }
17901   }
17902
17903   jresult = result;
17904   return jresult;
17905 }
17906
17907
17908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17909   unsigned int jresult ;
17910   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17911   Dali::Property::Map *arg2 = 0 ;
17912   bool result;
17913
17914   arg1 = (Dali::Property::Value *)jarg1;
17915   arg2 = (Dali::Property::Map *)jarg2;
17916   if (!arg2) {
17917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17918     return 0;
17919   }
17920   {
17921     try {
17922       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17923     } catch (std::out_of_range& e) {
17924       {
17925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17926       };
17927     } catch (std::exception& e) {
17928       {
17929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17930       };
17931     } catch (Dali::DaliException e) {
17932       {
17933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17934       };
17935     } catch (...) {
17936       {
17937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17938       };
17939     }
17940   }
17941
17942   jresult = result;
17943   return jresult;
17944 }
17945
17946
17947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17948   unsigned int jresult ;
17949   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17950   Extents *arg2 = 0 ;
17951   bool result;
17952
17953   arg1 = (Dali::Property::Value *)jarg1;
17954   arg2 = (Extents *)jarg2;
17955   if (!arg2) {
17956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17957     return 0;
17958   }
17959   {
17960     try {
17961       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17962     } catch (std::out_of_range& e) {
17963       {
17964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17965       };
17966     } catch (std::exception& e) {
17967       {
17968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17969       };
17970     } catch (...) {
17971       {
17972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17973       };
17974     }
17975   }
17976   jresult = result;
17977   return jresult;
17978 }
17979
17980
17981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17982   void * jresult ;
17983   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17984   Dali::Property::Array *result = 0 ;
17985
17986   arg1 = (Dali::Property::Value *)jarg1;
17987   {
17988     try {
17989       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17990     } catch (std::out_of_range& e) {
17991       {
17992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17993       };
17994     } catch (std::exception& e) {
17995       {
17996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17997       };
17998     } catch (Dali::DaliException e) {
17999       {
18000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18001       };
18002     } catch (...) {
18003       {
18004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18005       };
18006     }
18007   }
18008
18009   jresult = (void *)result;
18010   return jresult;
18011 }
18012
18013
18014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
18015   void * jresult ;
18016   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18017   Dali::Property::Map *result = 0 ;
18018
18019   arg1 = (Dali::Property::Value *)jarg1;
18020   {
18021     try {
18022       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18023     } catch (std::out_of_range& e) {
18024       {
18025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18026       };
18027     } catch (std::exception& e) {
18028       {
18029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18030       };
18031     } catch (Dali::DaliException e) {
18032       {
18033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18034       };
18035     } catch (...) {
18036       {
18037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18038       };
18039     }
18040   }
18041
18042   jresult = (void *)result;
18043   return jresult;
18044 }
18045
18046
18047 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18048   char * jresult ;
18049   Dali::Property::Type arg1 ;
18050   char *result = 0 ;
18051
18052   arg1 = (Dali::Property::Type)jarg1;
18053   {
18054     try {
18055       result = (char *)Dali::PropertyTypes::GetName(arg1);
18056     } catch (std::out_of_range& e) {
18057       {
18058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18059       };
18060     } catch (std::exception& e) {
18061       {
18062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18063       };
18064     } catch (Dali::DaliException e) {
18065       {
18066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18067       };
18068     } catch (...) {
18069       {
18070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18071       };
18072     }
18073   }
18074
18075   jresult = SWIG_csharp_string_callback((const char *)result);
18076   return jresult;
18077 }
18078
18079
18080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18081   unsigned int jresult ;
18082   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18083   std::string *arg2 = 0 ;
18084   Dali::Property::Map *arg3 = 0 ;
18085   bool result;
18086
18087   arg1 = (Dali::BaseObject *)jarg1;
18088   if (!jarg2) {
18089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18090     return 0;
18091   }
18092   std::string arg2_str(jarg2);
18093   arg2 = &arg2_str;
18094   arg3 = (Dali::Property::Map *)jarg3;
18095   if (!arg3) {
18096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18097     return 0;
18098   }
18099   {
18100     try {
18101       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18102     } catch (std::out_of_range& e) {
18103       {
18104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18105       };
18106     } catch (std::exception& e) {
18107       {
18108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18109       };
18110     } catch (Dali::DaliException e) {
18111       {
18112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18113       };
18114     } catch (...) {
18115       {
18116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18117       };
18118     }
18119   }
18120
18121   jresult = result;
18122
18123   //argout typemap for const std::string&
18124
18125   return jresult;
18126 }
18127
18128
18129 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18130   char * jresult ;
18131   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18132   std::string *result = 0 ;
18133
18134   arg1 = (Dali::BaseObject *)jarg1;
18135   {
18136     try {
18137       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18138     } catch (std::out_of_range& e) {
18139       {
18140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18141       };
18142     } catch (std::exception& e) {
18143       {
18144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18145       };
18146     } catch (Dali::DaliException e) {
18147       {
18148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18149       };
18150     } catch (...) {
18151       {
18152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18153       };
18154     }
18155   }
18156
18157   jresult = SWIG_csharp_string_callback(result->c_str());
18158   return jresult;
18159 }
18160
18161
18162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18163   unsigned int jresult ;
18164   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18165   Dali::TypeInfo *arg2 = 0 ;
18166   bool result;
18167
18168   arg1 = (Dali::BaseObject *)jarg1;
18169   arg2 = (Dali::TypeInfo *)jarg2;
18170   if (!arg2) {
18171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18172     return 0;
18173   }
18174   {
18175     try {
18176       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18177     } catch (std::out_of_range& e) {
18178       {
18179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18180       };
18181     } catch (std::exception& e) {
18182       {
18183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18184       };
18185     } catch (Dali::DaliException e) {
18186       {
18187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18188       };
18189     } catch (...) {
18190       {
18191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18192       };
18193     }
18194   }
18195
18196   jresult = result;
18197   return jresult;
18198 }
18199
18200
18201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18202   unsigned int jresult ;
18203   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18204   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18205   std::string *arg3 = 0 ;
18206   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18207   bool result;
18208
18209   arg1 = (Dali::BaseObject *)jarg1;
18210   arg2 = (ConnectionTrackerInterface *)jarg2;
18211   if (!jarg3) {
18212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18213     return 0;
18214   }
18215   std::string arg3_str(jarg3);
18216   arg3 = &arg3_str;
18217   arg4 = (FunctorDelegate *)jarg4;
18218   {
18219     try {
18220       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18221     } catch (std::out_of_range& e) {
18222       {
18223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18224       };
18225     } catch (std::exception& e) {
18226       {
18227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18228       };
18229     } catch (Dali::DaliException e) {
18230       {
18231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18232       };
18233     } catch (...) {
18234       {
18235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18236       };
18237     }
18238   }
18239
18240   jresult = result;
18241
18242   //argout typemap for const std::string&
18243
18244   return jresult;
18245 }
18246
18247
18248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18249   void * jresult ;
18250   Dali::BaseHandle *arg1 = 0 ;
18251   Dali::BaseObject *result = 0 ;
18252
18253   arg1 = (Dali::BaseHandle *)jarg1;
18254   if (!arg1) {
18255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18256     return 0;
18257   }
18258   {
18259     try {
18260       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18261     } catch (std::out_of_range& e) {
18262       {
18263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18264       };
18265     } catch (std::exception& e) {
18266       {
18267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18268       };
18269     } catch (Dali::DaliException e) {
18270       {
18271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18272       };
18273     } catch (...) {
18274       {
18275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18276       };
18277     }
18278   }
18279
18280   jresult = (void *)result;
18281   return jresult;
18282 }
18283
18284
18285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18286   void * jresult ;
18287   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18288   Dali::BaseHandle *result = 0 ;
18289
18290   arg1 = (Dali::BaseObject *)jarg1;
18291   {
18292     try {
18293       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18294     } catch (std::out_of_range& e) {
18295       {
18296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18297       };
18298     } catch (std::exception& e) {
18299       {
18300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18301       };
18302     } catch (Dali::DaliException e) {
18303       {
18304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18305       };
18306     } catch (...) {
18307       {
18308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18309       };
18310     }
18311   }
18312
18313   jresult = (void *)result;
18314   return jresult;
18315 }
18316
18317
18318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18319   void * jresult ;
18320   Dali::BaseHandle *result = 0 ;
18321
18322   {
18323     try {
18324       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18325     } catch (std::out_of_range& e) {
18326       {
18327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18328       };
18329     } catch (std::exception& e) {
18330       {
18331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18332       };
18333     } catch (Dali::DaliException e) {
18334       {
18335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18336       };
18337     } catch (...) {
18338       {
18339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18340       };
18341     }
18342   }
18343
18344   jresult = (void *)result;
18345   return jresult;
18346 }
18347
18348
18349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18350   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18351
18352   arg1 = (Dali::BaseHandle *)jarg1;
18353   {
18354     try {
18355       delete arg1;
18356     } catch (std::out_of_range& e) {
18357       {
18358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18359       };
18360     } catch (std::exception& e) {
18361       {
18362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18363       };
18364     } catch (Dali::DaliException e) {
18365       {
18366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18367       };
18368     } catch (...) {
18369       {
18370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18371       };
18372     }
18373   }
18374
18375 }
18376
18377
18378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18379   void * jresult ;
18380   Dali::BaseHandle *arg1 = 0 ;
18381   Dali::BaseHandle *result = 0 ;
18382
18383   arg1 = (Dali::BaseHandle *)jarg1;
18384   if (!arg1) {
18385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18386     return 0;
18387   }
18388   {
18389     try {
18390       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18391     } catch (std::out_of_range& e) {
18392       {
18393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18394       };
18395     } catch (std::exception& e) {
18396       {
18397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18398       };
18399     } catch (Dali::DaliException e) {
18400       {
18401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18402       };
18403     } catch (...) {
18404       {
18405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18406       };
18407     }
18408   }
18409
18410   jresult = (void *)result;
18411   return jresult;
18412 }
18413
18414
18415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18416   void * jresult ;
18417   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18418   Dali::BaseHandle *arg2 = 0 ;
18419   Dali::BaseHandle *result = 0 ;
18420
18421   arg1 = (Dali::BaseHandle *)jarg1;
18422   arg2 = (Dali::BaseHandle *)jarg2;
18423   if (!arg2) {
18424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18425     return 0;
18426   }
18427   {
18428     try {
18429       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18430     } catch (std::out_of_range& e) {
18431       {
18432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18433       };
18434     } catch (std::exception& e) {
18435       {
18436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18437       };
18438     } catch (Dali::DaliException e) {
18439       {
18440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18441       };
18442     } catch (...) {
18443       {
18444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18445       };
18446     }
18447   }
18448
18449   jresult = (void *)result;
18450   return jresult;
18451 }
18452
18453
18454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18455   unsigned int jresult ;
18456   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18457   std::string *arg2 = 0 ;
18458   Dali::Property::Map *arg3 = 0 ;
18459   bool result;
18460
18461   arg1 = (Dali::BaseHandle *)jarg1;
18462   if (!jarg2) {
18463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18464     return 0;
18465   }
18466   std::string arg2_str(jarg2);
18467   arg2 = &arg2_str;
18468   arg3 = (Dali::Property::Map *)jarg3;
18469   if (!arg3) {
18470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18471     return 0;
18472   }
18473   {
18474     try {
18475       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18476     } catch (std::out_of_range& e) {
18477       {
18478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18479       };
18480     } catch (std::exception& e) {
18481       {
18482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18483       };
18484     } catch (Dali::DaliException e) {
18485       {
18486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18487       };
18488     } catch (...) {
18489       {
18490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18491       };
18492     }
18493   }
18494
18495   jresult = result;
18496
18497   //argout typemap for const std::string&
18498
18499   return jresult;
18500 }
18501
18502
18503 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18504   char * jresult ;
18505   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18506   std::string *result = 0 ;
18507
18508   arg1 = (Dali::BaseHandle *)jarg1;
18509   {
18510     try {
18511       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18512     } catch (std::out_of_range& e) {
18513       {
18514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18515       };
18516     } catch (std::exception& e) {
18517       {
18518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18519       };
18520     } catch (Dali::DaliException e) {
18521       {
18522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18523       };
18524     } catch (...) {
18525       {
18526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18527       };
18528     }
18529   }
18530
18531   jresult = SWIG_csharp_string_callback(result->c_str());
18532   return jresult;
18533 }
18534
18535
18536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18537   unsigned int jresult ;
18538   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18539   Dali::TypeInfo *arg2 = 0 ;
18540   bool result;
18541
18542   arg1 = (Dali::BaseHandle *)jarg1;
18543   arg2 = (Dali::TypeInfo *)jarg2;
18544   if (!arg2) {
18545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18546     return 0;
18547   }
18548   {
18549     try {
18550       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18551     } catch (std::out_of_range& e) {
18552       {
18553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18554       };
18555     } catch (std::exception& e) {
18556       {
18557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18558       };
18559     } catch (Dali::DaliException e) {
18560       {
18561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18562       };
18563     } catch (...) {
18564       {
18565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18566       };
18567     }
18568   }
18569
18570   jresult = result;
18571   return jresult;
18572 }
18573
18574
18575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18576   void * jresult ;
18577   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18578   Dali::BaseObject *result = 0 ;
18579
18580   arg1 = (Dali::BaseHandle *)jarg1;
18581   {
18582     try {
18583       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18584     } catch (std::out_of_range& e) {
18585       {
18586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18587       };
18588     } catch (std::exception& e) {
18589       {
18590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18591       };
18592     } catch (Dali::DaliException e) {
18593       {
18594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18595       };
18596     } catch (...) {
18597       {
18598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18599       };
18600     }
18601   }
18602
18603   jresult = (void *)result;
18604   return jresult;
18605 }
18606
18607
18608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18609   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18610
18611   arg1 = (Dali::BaseHandle *)jarg1;
18612   {
18613     try {
18614       (arg1)->Reset();
18615     } catch (std::out_of_range& e) {
18616       {
18617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18618       };
18619     } catch (std::exception& e) {
18620       {
18621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18622       };
18623     } catch (Dali::DaliException e) {
18624       {
18625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18626       };
18627     } catch (...) {
18628       {
18629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18630       };
18631     }
18632   }
18633
18634 }
18635
18636
18637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18638   unsigned int jresult ;
18639   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18640   Dali::BaseHandle *arg2 = 0 ;
18641   bool result;
18642
18643   arg1 = (Dali::BaseHandle *)jarg1;
18644   arg2 = (Dali::BaseHandle *)jarg2;
18645   if (!arg2) {
18646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18647     return 0;
18648   }
18649   {
18650     try {
18651       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18652     } catch (std::out_of_range& e) {
18653       {
18654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18655       };
18656     } catch (std::exception& e) {
18657       {
18658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18659       };
18660     } catch (Dali::DaliException e) {
18661       {
18662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18663       };
18664     } catch (...) {
18665       {
18666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18667       };
18668     }
18669   }
18670
18671   jresult = result;
18672   return jresult;
18673 }
18674
18675
18676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18677   unsigned int jresult ;
18678   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18679   Dali::BaseHandle *arg2 = 0 ;
18680   bool result;
18681
18682   arg1 = (Dali::BaseHandle *)jarg1;
18683   arg2 = (Dali::BaseHandle *)jarg2;
18684   if (!arg2) {
18685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18686     return 0;
18687   }
18688   {
18689     try {
18690       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18691     } catch (std::out_of_range& e) {
18692       {
18693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18694       };
18695     } catch (std::exception& e) {
18696       {
18697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18698       };
18699     } catch (Dali::DaliException e) {
18700       {
18701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18702       };
18703     } catch (...) {
18704       {
18705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18706       };
18707     }
18708   }
18709
18710   jresult = result;
18711   return jresult;
18712 }
18713
18714
18715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18716   void * jresult ;
18717   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18718   Dali::RefObject *result = 0 ;
18719
18720   arg1 = (Dali::BaseHandle *)jarg1;
18721   {
18722     try {
18723       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18724     } catch (std::out_of_range& e) {
18725       {
18726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18727       };
18728     } catch (std::exception& e) {
18729       {
18730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18731       };
18732     } catch (Dali::DaliException e) {
18733       {
18734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18735       };
18736     } catch (...) {
18737       {
18738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18739       };
18740     }
18741   }
18742
18743   jresult = (void *)result;
18744   return jresult;
18745 }
18746
18747
18748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18749   unsigned int jresult ;
18750   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18751   bool result;
18752
18753   arg1 = (Dali::BaseHandle *)jarg1;
18754   {
18755     try {
18756       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18757     } catch (std::out_of_range& e) {
18758       {
18759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18760       };
18761     } catch (std::exception& e) {
18762       {
18763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18764       };
18765     } catch (Dali::DaliException e) {
18766       {
18767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18768       };
18769     } catch (...) {
18770       {
18771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18772       };
18773     }
18774   }
18775
18776   jresult = result;
18777   return jresult;
18778 }
18779
18780
18781 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18782   unsigned int jresult ;
18783   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18784   Dali::BaseHandle *arg2 = 0 ;
18785   bool result;
18786
18787   arg1 = (Dali::BaseHandle *)jarg1;
18788   arg2 = (Dali::BaseHandle *)jarg2;
18789   if (!arg2) {
18790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18791     return 0;
18792   }
18793   {
18794     try {
18795       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18796     } catch (std::out_of_range& e) {
18797       {
18798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18799       };
18800     } catch (std::exception& e) {
18801       {
18802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18803       };
18804     } catch (Dali::DaliException e) {
18805       {
18806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18807       };
18808     } catch (...) {
18809       {
18810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18811       };
18812     }
18813   }
18814
18815   jresult = result;
18816   return jresult;
18817 }
18818
18819
18820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18821   unsigned int jresult ;
18822   Dali::BaseHandle *arg1 = 0 ;
18823   Dali::BaseHandle *arg2 = 0 ;
18824   bool result;
18825
18826   arg1 = (Dali::BaseHandle *)jarg1;
18827   if (!arg1) {
18828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18829     return 0;
18830   }
18831   arg2 = (Dali::BaseHandle *)jarg2;
18832   if (!arg2) {
18833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18834     return 0;
18835   }
18836   {
18837     try {
18838       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18839     } catch (std::out_of_range& e) {
18840       {
18841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18842       };
18843     } catch (std::exception& e) {
18844       {
18845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18846       };
18847     } catch (Dali::DaliException e) {
18848       {
18849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18850       };
18851     } catch (...) {
18852       {
18853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18854       };
18855     }
18856   }
18857
18858   jresult = result;
18859   return jresult;
18860 }
18861
18862
18863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18864   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18865
18866   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18867   {
18868     try {
18869       delete arg1;
18870     } catch (std::out_of_range& e) {
18871       {
18872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18873       };
18874     } catch (std::exception& e) {
18875       {
18876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18877       };
18878     } catch (Dali::DaliException e) {
18879       {
18880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18881       };
18882     } catch (...) {
18883       {
18884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18885       };
18886     }
18887   }
18888
18889 }
18890
18891
18892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18893   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18894   SlotObserver *arg2 = (SlotObserver *) 0 ;
18895   CallbackBase *arg3 = (CallbackBase *) 0 ;
18896
18897   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18898   arg2 = (SlotObserver *)jarg2;
18899   arg3 = (CallbackBase *)jarg3;
18900   {
18901     try {
18902       (arg1)->SignalConnected(arg2,arg3);
18903     } catch (std::out_of_range& e) {
18904       {
18905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18906       };
18907     } catch (std::exception& e) {
18908       {
18909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18910       };
18911     } catch (Dali::DaliException e) {
18912       {
18913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18914       };
18915     } catch (...) {
18916       {
18917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18918       };
18919     }
18920   }
18921
18922 }
18923
18924
18925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18926   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18927
18928   arg1 = (Dali::SignalObserver *)jarg1;
18929   {
18930     try {
18931       delete arg1;
18932     } catch (std::out_of_range& e) {
18933       {
18934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18935       };
18936     } catch (std::exception& e) {
18937       {
18938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18939       };
18940     } catch (Dali::DaliException e) {
18941       {
18942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18943       };
18944     } catch (...) {
18945       {
18946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18947       };
18948     }
18949   }
18950
18951 }
18952
18953
18954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18955   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18956   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18957   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18958
18959   arg1 = (Dali::SignalObserver *)jarg1;
18960   arg2 = (Dali::SlotObserver *)jarg2;
18961   arg3 = (Dali::CallbackBase *)jarg3;
18962   {
18963     try {
18964       (arg1)->SignalDisconnected(arg2,arg3);
18965     } catch (std::out_of_range& e) {
18966       {
18967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18968       };
18969     } catch (std::exception& e) {
18970       {
18971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18972       };
18973     } catch (Dali::DaliException e) {
18974       {
18975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18976       };
18977     } catch (...) {
18978       {
18979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18980       };
18981     }
18982   }
18983
18984 }
18985
18986
18987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18988   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18989
18990   arg1 = (Dali::SlotObserver *)jarg1;
18991   {
18992     try {
18993       delete arg1;
18994     } catch (std::out_of_range& e) {
18995       {
18996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18997       };
18998     } catch (std::exception& e) {
18999       {
19000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19001       };
19002     } catch (Dali::DaliException e) {
19003       {
19004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19005       };
19006     } catch (...) {
19007       {
19008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19009       };
19010     }
19011   }
19012
19013 }
19014
19015
19016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19017   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19018   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19019
19020   arg1 = (Dali::SlotObserver *)jarg1;
19021   arg2 = (Dali::CallbackBase *)jarg2;
19022   {
19023     try {
19024       (arg1)->SlotDisconnected(arg2);
19025     } catch (std::out_of_range& e) {
19026       {
19027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19028       };
19029     } catch (std::exception& e) {
19030       {
19031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19032       };
19033     } catch (Dali::DaliException e) {
19034       {
19035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19036       };
19037     } catch (...) {
19038       {
19039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19040       };
19041     }
19042   }
19043
19044 }
19045
19046
19047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19048   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19049
19050   arg1 = (Dali::ConnectionTracker *)jarg1;
19051   {
19052     try {
19053       delete arg1;
19054     } catch (std::out_of_range& e) {
19055       {
19056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19057       };
19058     } catch (std::exception& e) {
19059       {
19060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19061       };
19062     } catch (Dali::DaliException e) {
19063       {
19064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19065       };
19066     } catch (...) {
19067       {
19068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19069       };
19070     }
19071   }
19072
19073 }
19074
19075
19076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19077   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19078
19079   arg1 = (Dali::ConnectionTracker *)jarg1;
19080   {
19081     try {
19082       (arg1)->DisconnectAll();
19083     } catch (std::out_of_range& e) {
19084       {
19085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19086       };
19087     } catch (std::exception& e) {
19088       {
19089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19090       };
19091     } catch (Dali::DaliException e) {
19092       {
19093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19094       };
19095     } catch (...) {
19096       {
19097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19098       };
19099     }
19100   }
19101
19102 }
19103
19104
19105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19106   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19107   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19108   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19109
19110   arg1 = (Dali::ConnectionTracker *)jarg1;
19111   arg2 = (Dali::SlotObserver *)jarg2;
19112   arg3 = (Dali::CallbackBase *)jarg3;
19113   {
19114     try {
19115       (arg1)->SignalConnected(arg2,arg3);
19116     } catch (std::out_of_range& e) {
19117       {
19118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19119       };
19120     } catch (std::exception& e) {
19121       {
19122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19123       };
19124     } catch (Dali::DaliException e) {
19125       {
19126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19127       };
19128     } catch (...) {
19129       {
19130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19131       };
19132     }
19133   }
19134
19135 }
19136
19137
19138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19139   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19140   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19141   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19142
19143   arg1 = (Dali::ConnectionTracker *)jarg1;
19144   arg2 = (Dali::SlotObserver *)jarg2;
19145   arg3 = (Dali::CallbackBase *)jarg3;
19146   {
19147     try {
19148       (arg1)->SignalDisconnected(arg2,arg3);
19149     } catch (std::out_of_range& e) {
19150       {
19151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19152       };
19153     } catch (std::exception& e) {
19154       {
19155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19156       };
19157     } catch (Dali::DaliException e) {
19158       {
19159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19160       };
19161     } catch (...) {
19162       {
19163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19164       };
19165     }
19166   }
19167
19168 }
19169
19170
19171 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19172   unsigned long jresult ;
19173   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19174   std::size_t result;
19175
19176   arg1 = (Dali::ConnectionTracker *)jarg1;
19177   {
19178     try {
19179       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19180     } catch (std::out_of_range& e) {
19181       {
19182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19183       };
19184     } catch (std::exception& e) {
19185       {
19186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19187       };
19188     } catch (Dali::DaliException e) {
19189       {
19190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19191       };
19192     } catch (...) {
19193       {
19194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19195       };
19196     }
19197   }
19198
19199   jresult = (unsigned long)result;
19200   return jresult;
19201 }
19202
19203
19204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19205   void * jresult ;
19206   Dali::ObjectRegistry *result = 0 ;
19207
19208   {
19209     try {
19210       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19211     } catch (std::out_of_range& e) {
19212       {
19213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19214       };
19215     } catch (std::exception& e) {
19216       {
19217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19218       };
19219     } catch (Dali::DaliException e) {
19220       {
19221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19222       };
19223     } catch (...) {
19224       {
19225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19226       };
19227     }
19228   }
19229
19230   jresult = (void *)result;
19231   return jresult;
19232 }
19233
19234
19235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19236   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19237
19238   arg1 = (Dali::ObjectRegistry *)jarg1;
19239   {
19240     try {
19241       delete arg1;
19242     } catch (std::out_of_range& e) {
19243       {
19244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19245       };
19246     } catch (std::exception& e) {
19247       {
19248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19249       };
19250     } catch (Dali::DaliException e) {
19251       {
19252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19253       };
19254     } catch (...) {
19255       {
19256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19257       };
19258     }
19259   }
19260
19261 }
19262
19263
19264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19265   void * jresult ;
19266   Dali::ObjectRegistry *arg1 = 0 ;
19267   Dali::ObjectRegistry *result = 0 ;
19268
19269   arg1 = (Dali::ObjectRegistry *)jarg1;
19270   if (!arg1) {
19271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19272     return 0;
19273   }
19274   {
19275     try {
19276       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19277     } catch (std::out_of_range& e) {
19278       {
19279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19280       };
19281     } catch (std::exception& e) {
19282       {
19283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19284       };
19285     } catch (Dali::DaliException e) {
19286       {
19287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19288       };
19289     } catch (...) {
19290       {
19291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19292       };
19293     }
19294   }
19295
19296   jresult = (void *)result;
19297   return jresult;
19298 }
19299
19300
19301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19302   void * jresult ;
19303   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19304   Dali::ObjectRegistry *arg2 = 0 ;
19305   Dali::ObjectRegistry *result = 0 ;
19306
19307   arg1 = (Dali::ObjectRegistry *)jarg1;
19308   arg2 = (Dali::ObjectRegistry *)jarg2;
19309   if (!arg2) {
19310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19311     return 0;
19312   }
19313   {
19314     try {
19315       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19316     } catch (std::out_of_range& e) {
19317       {
19318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19319       };
19320     } catch (std::exception& e) {
19321       {
19322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19323       };
19324     } catch (Dali::DaliException e) {
19325       {
19326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19327       };
19328     } catch (...) {
19329       {
19330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19331       };
19332     }
19333   }
19334
19335   jresult = (void *)result;
19336   return jresult;
19337 }
19338
19339
19340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19341   void * jresult ;
19342   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19343   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19344
19345   arg1 = (Dali::ObjectRegistry *)jarg1;
19346   {
19347     try {
19348       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19349     } catch (std::out_of_range& e) {
19350       {
19351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19352       };
19353     } catch (std::exception& e) {
19354       {
19355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19356       };
19357     } catch (Dali::DaliException e) {
19358       {
19359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19360       };
19361     } catch (...) {
19362       {
19363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19364       };
19365     }
19366   }
19367
19368   jresult = (void *)result;
19369   return jresult;
19370 }
19371
19372
19373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19374   void * jresult ;
19375   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19376   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19377
19378   arg1 = (Dali::ObjectRegistry *)jarg1;
19379   {
19380     try {
19381       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19382     } catch (std::out_of_range& e) {
19383       {
19384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19385       };
19386     } catch (std::exception& e) {
19387       {
19388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19389       };
19390     } catch (Dali::DaliException e) {
19391       {
19392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19393       };
19394     } catch (...) {
19395       {
19396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19397       };
19398     }
19399   }
19400
19401   jresult = (void *)result;
19402   return jresult;
19403 }
19404
19405
19406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19407   void * jresult ;
19408   Dali::PropertyCondition *result = 0 ;
19409
19410   {
19411     try {
19412       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19413     } catch (std::out_of_range& e) {
19414       {
19415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19416       };
19417     } catch (std::exception& e) {
19418       {
19419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19420       };
19421     } catch (Dali::DaliException e) {
19422       {
19423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19424       };
19425     } catch (...) {
19426       {
19427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19428       };
19429     }
19430   }
19431
19432   jresult = (void *)result;
19433   return jresult;
19434 }
19435
19436
19437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19438   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19439
19440   arg1 = (Dali::PropertyCondition *)jarg1;
19441   {
19442     try {
19443       delete arg1;
19444     } catch (std::out_of_range& e) {
19445       {
19446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19447       };
19448     } catch (std::exception& e) {
19449       {
19450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19451       };
19452     } catch (Dali::DaliException e) {
19453       {
19454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19455       };
19456     } catch (...) {
19457       {
19458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19459       };
19460     }
19461   }
19462
19463 }
19464
19465
19466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19467   void * jresult ;
19468   Dali::PropertyCondition *arg1 = 0 ;
19469   Dali::PropertyCondition *result = 0 ;
19470
19471   arg1 = (Dali::PropertyCondition *)jarg1;
19472   if (!arg1) {
19473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19474     return 0;
19475   }
19476   {
19477     try {
19478       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19479     } catch (std::out_of_range& e) {
19480       {
19481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19482       };
19483     } catch (std::exception& e) {
19484       {
19485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19486       };
19487     } catch (Dali::DaliException e) {
19488       {
19489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19490       };
19491     } catch (...) {
19492       {
19493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19494       };
19495     }
19496   }
19497
19498   jresult = (void *)result;
19499   return jresult;
19500 }
19501
19502
19503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19504   void * jresult ;
19505   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19506   Dali::PropertyCondition *arg2 = 0 ;
19507   Dali::PropertyCondition *result = 0 ;
19508
19509   arg1 = (Dali::PropertyCondition *)jarg1;
19510   arg2 = (Dali::PropertyCondition *)jarg2;
19511   if (!arg2) {
19512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19513     return 0;
19514   }
19515   {
19516     try {
19517       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19518     } catch (std::out_of_range& e) {
19519       {
19520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19521       };
19522     } catch (std::exception& e) {
19523       {
19524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19525       };
19526     } catch (Dali::DaliException e) {
19527       {
19528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19529       };
19530     } catch (...) {
19531       {
19532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19533       };
19534     }
19535   }
19536
19537   jresult = (void *)result;
19538   return jresult;
19539 }
19540
19541
19542 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19543   unsigned long jresult ;
19544   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19545   std::size_t result;
19546
19547   arg1 = (Dali::PropertyCondition *)jarg1;
19548   {
19549     try {
19550       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19551     } catch (std::out_of_range& e) {
19552       {
19553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19554       };
19555     } catch (std::exception& e) {
19556       {
19557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19558       };
19559     } catch (...) {
19560       {
19561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19562       };
19563     }
19564   }
19565   jresult = (unsigned long)result;
19566   return jresult;
19567 }
19568
19569
19570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19571   float jresult ;
19572   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19573   std::size_t arg2 ;
19574   float result;
19575
19576   arg1 = (Dali::PropertyCondition *)jarg1;
19577   arg2 = (std::size_t)jarg2;
19578   {
19579     try {
19580       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19581     } catch (std::out_of_range& e) {
19582       {
19583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19584       };
19585     } catch (std::exception& e) {
19586       {
19587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19588       };
19589     } catch (...) {
19590       {
19591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19592       };
19593     }
19594   }
19595   jresult = result;
19596   return jresult;
19597 }
19598
19599
19600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19601   void * jresult ;
19602   float arg1 ;
19603   Dali::PropertyCondition result;
19604
19605   arg1 = (float)jarg1;
19606   {
19607     try {
19608       result = Dali::LessThanCondition(arg1);
19609     } catch (std::out_of_range& e) {
19610       {
19611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19612       };
19613     } catch (std::exception& e) {
19614       {
19615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19616       };
19617     } catch (Dali::DaliException e) {
19618       {
19619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19620       };
19621     } catch (...) {
19622       {
19623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19624       };
19625     }
19626   }
19627
19628   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19629   return jresult;
19630 }
19631
19632
19633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19634   void * jresult ;
19635   float arg1 ;
19636   Dali::PropertyCondition result;
19637
19638   arg1 = (float)jarg1;
19639   {
19640     try {
19641       result = Dali::GreaterThanCondition(arg1);
19642     } catch (std::out_of_range& e) {
19643       {
19644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19645       };
19646     } catch (std::exception& e) {
19647       {
19648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19649       };
19650     } catch (Dali::DaliException e) {
19651       {
19652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19653       };
19654     } catch (...) {
19655       {
19656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19657       };
19658     }
19659   }
19660
19661   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19662   return jresult;
19663 }
19664
19665
19666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19667   void * jresult ;
19668   float arg1 ;
19669   float arg2 ;
19670   Dali::PropertyCondition result;
19671
19672   arg1 = (float)jarg1;
19673   arg2 = (float)jarg2;
19674   {
19675     try {
19676       result = Dali::InsideCondition(arg1,arg2);
19677     } catch (std::out_of_range& e) {
19678       {
19679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19680       };
19681     } catch (std::exception& e) {
19682       {
19683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19684       };
19685     } catch (Dali::DaliException e) {
19686       {
19687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19688       };
19689     } catch (...) {
19690       {
19691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19692       };
19693     }
19694   }
19695
19696   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19697   return jresult;
19698 }
19699
19700
19701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19702   void * jresult ;
19703   float arg1 ;
19704   float arg2 ;
19705   Dali::PropertyCondition result;
19706
19707   arg1 = (float)jarg1;
19708   arg2 = (float)jarg2;
19709   {
19710     try {
19711       result = Dali::OutsideCondition(arg1,arg2);
19712     } catch (std::out_of_range& e) {
19713       {
19714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19715       };
19716     } catch (std::exception& e) {
19717       {
19718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19719       };
19720     } catch (Dali::DaliException e) {
19721       {
19722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19723       };
19724     } catch (...) {
19725       {
19726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19727       };
19728     }
19729   }
19730
19731   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19732   return jresult;
19733 }
19734
19735
19736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19737   void * jresult ;
19738   float arg1 ;
19739   float arg2 ;
19740   Dali::PropertyCondition result;
19741
19742   arg1 = (float)jarg1;
19743   arg2 = (float)jarg2;
19744   {
19745     try {
19746       result = Dali::StepCondition(arg1,arg2);
19747     } catch (std::out_of_range& e) {
19748       {
19749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19750       };
19751     } catch (std::exception& e) {
19752       {
19753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19754       };
19755     } catch (Dali::DaliException e) {
19756       {
19757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19758       };
19759     } catch (...) {
19760       {
19761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19762       };
19763     }
19764   }
19765
19766   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19767   return jresult;
19768 }
19769
19770
19771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19772   void * jresult ;
19773   float arg1 ;
19774   Dali::PropertyCondition result;
19775
19776   arg1 = (float)jarg1;
19777   {
19778     try {
19779       result = Dali::StepCondition(arg1);
19780     } catch (std::out_of_range& e) {
19781       {
19782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19783       };
19784     } catch (std::exception& e) {
19785       {
19786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19787       };
19788     } catch (Dali::DaliException e) {
19789       {
19790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19791       };
19792     } catch (...) {
19793       {
19794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19795       };
19796     }
19797   }
19798
19799   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19800   return jresult;
19801 }
19802
19803
19804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19805   void * jresult ;
19806   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19807   Dali::PropertyCondition result;
19808
19809   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19810   if (!arg1) {
19811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19812     return 0;
19813   }
19814   {
19815     try {
19816       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19817     } catch (std::out_of_range& e) {
19818       {
19819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19820       };
19821     } catch (std::exception& e) {
19822       {
19823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19824       };
19825     } catch (Dali::DaliException e) {
19826       {
19827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19828       };
19829     } catch (...) {
19830       {
19831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19832       };
19833     }
19834   }
19835
19836   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19837   return jresult;
19838 }
19839
19840
19841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19842   void * jresult ;
19843   Dali::PropertyNotification *result = 0 ;
19844
19845   {
19846     try {
19847       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19848     } catch (std::out_of_range& e) {
19849       {
19850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19851       };
19852     } catch (std::exception& e) {
19853       {
19854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19855       };
19856     } catch (Dali::DaliException e) {
19857       {
19858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19859       };
19860     } catch (...) {
19861       {
19862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19863       };
19864     }
19865   }
19866
19867   jresult = (void *)result;
19868   return jresult;
19869 }
19870
19871
19872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19873   void * jresult ;
19874   Dali::BaseHandle arg1 ;
19875   Dali::BaseHandle *argp1 ;
19876   Dali::PropertyNotification result;
19877
19878   argp1 = (Dali::BaseHandle *)jarg1;
19879   if (!argp1) {
19880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19881     return 0;
19882   }
19883   arg1 = *argp1;
19884   {
19885     try {
19886       result = Dali::PropertyNotification::DownCast(arg1);
19887     } catch (std::out_of_range& e) {
19888       {
19889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19890       };
19891     } catch (std::exception& e) {
19892       {
19893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19894       };
19895     } catch (Dali::DaliException e) {
19896       {
19897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19898       };
19899     } catch (...) {
19900       {
19901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19902       };
19903     }
19904   }
19905
19906   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19907   return jresult;
19908 }
19909
19910
19911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19912   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19913
19914   arg1 = (Dali::PropertyNotification *)jarg1;
19915   {
19916     try {
19917       delete arg1;
19918     } catch (std::out_of_range& e) {
19919       {
19920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19921       };
19922     } catch (std::exception& e) {
19923       {
19924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19925       };
19926     } catch (Dali::DaliException e) {
19927       {
19928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19929       };
19930     } catch (...) {
19931       {
19932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19933       };
19934     }
19935   }
19936
19937 }
19938
19939
19940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19941   void * jresult ;
19942   Dali::PropertyNotification *arg1 = 0 ;
19943   Dali::PropertyNotification *result = 0 ;
19944
19945   arg1 = (Dali::PropertyNotification *)jarg1;
19946   if (!arg1) {
19947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19948     return 0;
19949   }
19950   {
19951     try {
19952       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19953     } catch (std::out_of_range& e) {
19954       {
19955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19956       };
19957     } catch (std::exception& e) {
19958       {
19959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19960       };
19961     } catch (Dali::DaliException e) {
19962       {
19963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19964       };
19965     } catch (...) {
19966       {
19967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19968       };
19969     }
19970   }
19971
19972   jresult = (void *)result;
19973   return jresult;
19974 }
19975
19976
19977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19978   void * jresult ;
19979   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19980   Dali::PropertyNotification *arg2 = 0 ;
19981   Dali::PropertyNotification *result = 0 ;
19982
19983   arg1 = (Dali::PropertyNotification *)jarg1;
19984   arg2 = (Dali::PropertyNotification *)jarg2;
19985   if (!arg2) {
19986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19987     return 0;
19988   }
19989   {
19990     try {
19991       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19992     } catch (std::out_of_range& e) {
19993       {
19994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19995       };
19996     } catch (std::exception& e) {
19997       {
19998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19999       };
20000     } catch (Dali::DaliException e) {
20001       {
20002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20003       };
20004     } catch (...) {
20005       {
20006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20007       };
20008     }
20009   }
20010
20011   jresult = (void *)result;
20012   return jresult;
20013 }
20014
20015
20016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20017   void * jresult ;
20018   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20019   Dali::PropertyCondition result;
20020
20021   arg1 = (Dali::PropertyNotification *)jarg1;
20022   {
20023     try {
20024       result = (arg1)->GetCondition();
20025     } catch (std::out_of_range& e) {
20026       {
20027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20028       };
20029     } catch (std::exception& e) {
20030       {
20031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20032       };
20033     } catch (Dali::DaliException e) {
20034       {
20035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20036       };
20037     } catch (...) {
20038       {
20039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20040       };
20041     }
20042   }
20043
20044   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20045   return jresult;
20046 }
20047
20048
20049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20050   void * jresult ;
20051   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20052   Dali::Handle result;
20053
20054   arg1 = (Dali::PropertyNotification *)jarg1;
20055   {
20056     try {
20057       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20058     } catch (std::out_of_range& e) {
20059       {
20060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20061       };
20062     } catch (std::exception& e) {
20063       {
20064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20065       };
20066     } catch (Dali::DaliException e) {
20067       {
20068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20069       };
20070     } catch (...) {
20071       {
20072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20073       };
20074     }
20075   }
20076
20077   jresult = new Dali::Handle((const Dali::Handle &)result);
20078   return jresult;
20079 }
20080
20081
20082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20083   int jresult ;
20084   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20085   Dali::Property::Index result;
20086
20087   arg1 = (Dali::PropertyNotification *)jarg1;
20088   {
20089     try {
20090       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20091     } catch (std::out_of_range& e) {
20092       {
20093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20094       };
20095     } catch (std::exception& e) {
20096       {
20097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20098       };
20099     } catch (Dali::DaliException e) {
20100       {
20101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20102       };
20103     } catch (...) {
20104       {
20105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20106       };
20107     }
20108   }
20109
20110   jresult = result;
20111   return jresult;
20112 }
20113
20114
20115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20116   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20117   Dali::PropertyNotification::NotifyMode arg2 ;
20118
20119   arg1 = (Dali::PropertyNotification *)jarg1;
20120   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20121   {
20122     try {
20123       (arg1)->SetNotifyMode(arg2);
20124     } catch (std::out_of_range& e) {
20125       {
20126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20127       };
20128     } catch (std::exception& e) {
20129       {
20130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20131       };
20132     } catch (Dali::DaliException e) {
20133       {
20134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20135       };
20136     } catch (...) {
20137       {
20138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20139       };
20140     }
20141   }
20142
20143 }
20144
20145
20146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20147   int jresult ;
20148   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20149   Dali::PropertyNotification::NotifyMode result;
20150
20151   arg1 = (Dali::PropertyNotification *)jarg1;
20152   {
20153     try {
20154       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20155     } catch (std::out_of_range& e) {
20156       {
20157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20158       };
20159     } catch (std::exception& e) {
20160       {
20161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20162       };
20163     } catch (Dali::DaliException e) {
20164       {
20165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20166       };
20167     } catch (...) {
20168       {
20169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20170       };
20171     }
20172   }
20173
20174   jresult = (int)result;
20175   return jresult;
20176 }
20177
20178
20179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20180   unsigned int jresult ;
20181   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20182   bool result;
20183
20184   arg1 = (Dali::PropertyNotification *)jarg1;
20185   {
20186     try {
20187       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20188     } catch (std::out_of_range& e) {
20189       {
20190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20191       };
20192     } catch (std::exception& e) {
20193       {
20194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20195       };
20196     } catch (Dali::DaliException e) {
20197       {
20198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20199       };
20200     } catch (...) {
20201       {
20202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20203       };
20204     }
20205   }
20206
20207   jresult = result;
20208   return jresult;
20209 }
20210
20211
20212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20213   void * jresult ;
20214   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20215   Dali::PropertyNotifySignalType *result = 0 ;
20216
20217   arg1 = (Dali::PropertyNotification *)jarg1;
20218   {
20219     try {
20220       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20221     } catch (std::out_of_range& e) {
20222       {
20223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20224       };
20225     } catch (std::exception& e) {
20226       {
20227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20228       };
20229     } catch (Dali::DaliException e) {
20230       {
20231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20232       };
20233     } catch (...) {
20234       {
20235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20236       };
20237     }
20238   }
20239
20240   jresult = (void *)result;
20241   return jresult;
20242 }
20243
20244
20245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20246   void * jresult ;
20247   Dali::Handle *result = 0 ;
20248
20249   {
20250     try {
20251       result = (Dali::Handle *)new Dali::Handle();
20252     } catch (std::out_of_range& e) {
20253       {
20254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20255       };
20256     } catch (std::exception& e) {
20257       {
20258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20259       };
20260     } catch (Dali::DaliException e) {
20261       {
20262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20263       };
20264     } catch (...) {
20265       {
20266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20267       };
20268     }
20269   }
20270
20271   jresult = (void *)result;
20272   return jresult;
20273 }
20274
20275
20276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20277   void * jresult ;
20278   Dali::Handle result;
20279
20280   {
20281     try {
20282       result = Dali::Handle::New();
20283     } catch (std::out_of_range& e) {
20284       {
20285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20286       };
20287     } catch (std::exception& e) {
20288       {
20289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20290       };
20291     } catch (Dali::DaliException e) {
20292       {
20293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20294       };
20295     } catch (...) {
20296       {
20297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20298       };
20299     }
20300   }
20301
20302   jresult = new Dali::Handle((const Dali::Handle &)result);
20303   return jresult;
20304 }
20305
20306
20307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20308   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20309
20310   arg1 = (Dali::Handle *)jarg1;
20311   {
20312     try {
20313       delete arg1;
20314     } catch (std::out_of_range& e) {
20315       {
20316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20317       };
20318     } catch (std::exception& e) {
20319       {
20320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20321       };
20322     } catch (Dali::DaliException e) {
20323       {
20324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20325       };
20326     } catch (...) {
20327       {
20328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20329       };
20330     }
20331   }
20332
20333 }
20334
20335
20336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20337   void * jresult ;
20338   Dali::Handle *arg1 = 0 ;
20339   Dali::Handle *result = 0 ;
20340
20341   arg1 = (Dali::Handle *)jarg1;
20342   if (!arg1) {
20343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20344     return 0;
20345   }
20346   {
20347     try {
20348       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20349     } catch (std::out_of_range& e) {
20350       {
20351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20352       };
20353     } catch (std::exception& e) {
20354       {
20355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20356       };
20357     } catch (Dali::DaliException e) {
20358       {
20359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20360       };
20361     } catch (...) {
20362       {
20363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20364       };
20365     }
20366   }
20367
20368   jresult = (void *)result;
20369   return jresult;
20370 }
20371
20372
20373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20374   void * jresult ;
20375   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20376   Dali::Handle *arg2 = 0 ;
20377   Dali::Handle *result = 0 ;
20378
20379   arg1 = (Dali::Handle *)jarg1;
20380   arg2 = (Dali::Handle *)jarg2;
20381   if (!arg2) {
20382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20383     return 0;
20384   }
20385   {
20386     try {
20387       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20388     } catch (std::out_of_range& e) {
20389       {
20390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20391       };
20392     } catch (std::exception& e) {
20393       {
20394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20395       };
20396     } catch (Dali::DaliException e) {
20397       {
20398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20399       };
20400     } catch (...) {
20401       {
20402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20403       };
20404     }
20405   }
20406
20407   jresult = (void *)result;
20408   return jresult;
20409 }
20410
20411
20412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20413   void * jresult ;
20414   Dali::BaseHandle arg1 ;
20415   Dali::BaseHandle *argp1 ;
20416   Dali::Handle result;
20417
20418   argp1 = (Dali::BaseHandle *)jarg1;
20419   if (!argp1) {
20420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20421     return 0;
20422   }
20423   arg1 = *argp1;
20424   {
20425     try {
20426       result = Dali::Handle::DownCast(arg1);
20427     } catch (std::out_of_range& e) {
20428       {
20429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20430       };
20431     } catch (std::exception& e) {
20432       {
20433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20434       };
20435     } catch (Dali::DaliException e) {
20436       {
20437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20438       };
20439     } catch (...) {
20440       {
20441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20442       };
20443     }
20444   }
20445
20446   jresult = new Dali::Handle((const Dali::Handle &)result);
20447   return jresult;
20448 }
20449
20450
20451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20452   unsigned int jresult ;
20453   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20454   Dali::Handle::Capability arg2 ;
20455   bool result;
20456
20457   arg1 = (Dali::Handle *)jarg1;
20458   arg2 = (Dali::Handle::Capability)jarg2;
20459   {
20460     try {
20461       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20462     } catch (std::out_of_range& e) {
20463       {
20464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20465       };
20466     } catch (std::exception& e) {
20467       {
20468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20469       };
20470     } catch (Dali::DaliException e) {
20471       {
20472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20473       };
20474     } catch (...) {
20475       {
20476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20477       };
20478     }
20479   }
20480
20481   jresult = result;
20482   return jresult;
20483 }
20484
20485
20486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20487   unsigned int jresult ;
20488   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20489   unsigned int result;
20490
20491   arg1 = (Dali::Handle *)jarg1;
20492   {
20493     try {
20494       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20495     } catch (std::out_of_range& e) {
20496       {
20497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20498       };
20499     } catch (std::exception& e) {
20500       {
20501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20502       };
20503     } catch (Dali::DaliException e) {
20504       {
20505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20506       };
20507     } catch (...) {
20508       {
20509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20510       };
20511     }
20512   }
20513
20514   jresult = result;
20515   return jresult;
20516 }
20517
20518
20519 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20520   char * jresult ;
20521   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20522   Dali::Property::Index arg2 ;
20523   std::string result;
20524
20525   arg1 = (Dali::Handle *)jarg1;
20526   arg2 = (Dali::Property::Index)jarg2;
20527   {
20528     try {
20529       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20530     } catch (std::out_of_range& e) {
20531       {
20532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20533       };
20534     } catch (std::exception& e) {
20535       {
20536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20537       };
20538     } catch (Dali::DaliException e) {
20539       {
20540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20541       };
20542     } catch (...) {
20543       {
20544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20545       };
20546     }
20547   }
20548
20549   jresult = SWIG_csharp_string_callback((&result)->c_str());
20550   return jresult;
20551 }
20552
20553
20554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20555   int jresult ;
20556   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20557   std::string *arg2 = 0 ;
20558   Dali::Property::Index result;
20559
20560   arg1 = (Dali::Handle *)jarg1;
20561   if (!jarg2) {
20562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20563     return 0;
20564   }
20565   std::string arg2_str(jarg2);
20566   arg2 = &arg2_str;
20567   {
20568     try {
20569       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20570     } catch (std::out_of_range& e) {
20571       {
20572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20573       };
20574     } catch (std::exception& e) {
20575       {
20576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20577       };
20578     } catch (Dali::DaliException e) {
20579       {
20580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20581       };
20582     } catch (...) {
20583       {
20584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20585       };
20586     }
20587   }
20588
20589   jresult = result;
20590
20591   //argout typemap for const std::string&
20592
20593   return jresult;
20594 }
20595
20596
20597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20598   unsigned int jresult ;
20599   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20600   Dali::Property::Index arg2 ;
20601   bool result;
20602
20603   arg1 = (Dali::Handle *)jarg1;
20604   arg2 = (Dali::Property::Index)jarg2;
20605   {
20606     try {
20607       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20608     } catch (std::out_of_range& e) {
20609       {
20610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20611       };
20612     } catch (std::exception& e) {
20613       {
20614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20615       };
20616     } catch (Dali::DaliException e) {
20617       {
20618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20619       };
20620     } catch (...) {
20621       {
20622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20623       };
20624     }
20625   }
20626
20627   jresult = result;
20628   return jresult;
20629 }
20630
20631
20632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20633   unsigned int jresult ;
20634   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20635   Dali::Property::Index arg2 ;
20636   bool result;
20637
20638   arg1 = (Dali::Handle *)jarg1;
20639   arg2 = (Dali::Property::Index)jarg2;
20640   {
20641     try {
20642       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20643     } catch (std::out_of_range& e) {
20644       {
20645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20646       };
20647     } catch (std::exception& e) {
20648       {
20649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20650       };
20651     } catch (Dali::DaliException e) {
20652       {
20653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20654       };
20655     } catch (...) {
20656       {
20657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20658       };
20659     }
20660   }
20661
20662   jresult = result;
20663   return jresult;
20664 }
20665
20666
20667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20668   unsigned int jresult ;
20669   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20670   Dali::Property::Index arg2 ;
20671   bool result;
20672
20673   arg1 = (Dali::Handle *)jarg1;
20674   arg2 = (Dali::Property::Index)jarg2;
20675   {
20676     try {
20677       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20678     } catch (std::out_of_range& e) {
20679       {
20680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20681       };
20682     } catch (std::exception& e) {
20683       {
20684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20685       };
20686     } catch (Dali::DaliException e) {
20687       {
20688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20689       };
20690     } catch (...) {
20691       {
20692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20693       };
20694     }
20695   }
20696
20697   jresult = result;
20698   return jresult;
20699 }
20700
20701
20702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20703   int jresult ;
20704   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20705   Dali::Property::Index arg2 ;
20706   Dali::Property::Type result;
20707
20708   arg1 = (Dali::Handle *)jarg1;
20709   arg2 = (Dali::Property::Index)jarg2;
20710   {
20711     try {
20712       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20713     } catch (std::out_of_range& e) {
20714       {
20715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20716       };
20717     } catch (std::exception& e) {
20718       {
20719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20720       };
20721     } catch (Dali::DaliException e) {
20722       {
20723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20724       };
20725     } catch (...) {
20726       {
20727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20728       };
20729     }
20730   }
20731
20732   jresult = (int)result;
20733   return jresult;
20734 }
20735
20736
20737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20738   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20739   Dali::Property::Index arg2 ;
20740   Dali::Property::Value *arg3 = 0 ;
20741
20742   arg1 = (Dali::Handle *)jarg1;
20743   arg2 = (Dali::Property::Index)jarg2;
20744   arg3 = (Dali::Property::Value *)jarg3;
20745   if (!arg3) {
20746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20747     return ;
20748   }
20749   {
20750     try {
20751       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20752     } catch (std::out_of_range& e) {
20753       {
20754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20755       };
20756     } catch (std::exception& e) {
20757       {
20758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20759       };
20760     } catch (Dali::DaliException e) {
20761       {
20762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20763       };
20764     } catch (...) {
20765       {
20766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20767       };
20768     }
20769   }
20770
20771 }
20772
20773
20774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20775   int jresult ;
20776   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20777   std::string *arg2 = 0 ;
20778   Dali::Property::Value *arg3 = 0 ;
20779   Dali::Property::Index result;
20780
20781   arg1 = (Dali::Handle *)jarg1;
20782   if (!jarg2) {
20783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20784     return 0;
20785   }
20786   std::string arg2_str(jarg2);
20787   arg2 = &arg2_str;
20788   arg3 = (Dali::Property::Value *)jarg3;
20789   if (!arg3) {
20790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20791     return 0;
20792   }
20793   {
20794     try {
20795       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20796     } catch (std::out_of_range& e) {
20797       {
20798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20799       };
20800     } catch (std::exception& e) {
20801       {
20802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20803       };
20804     } catch (Dali::DaliException e) {
20805       {
20806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20807       };
20808     } catch (...) {
20809       {
20810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20811       };
20812     }
20813   }
20814
20815   jresult = result;
20816
20817   //argout typemap for const std::string&
20818
20819   return jresult;
20820 }
20821
20822
20823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20824   int jresult ;
20825   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20826   std::string *arg2 = 0 ;
20827   Dali::Property::Value *arg3 = 0 ;
20828   Dali::Property::AccessMode arg4 ;
20829   Dali::Property::Index result;
20830
20831   arg1 = (Dali::Handle *)jarg1;
20832   if (!jarg2) {
20833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20834     return 0;
20835   }
20836   std::string arg2_str(jarg2);
20837   arg2 = &arg2_str;
20838   arg3 = (Dali::Property::Value *)jarg3;
20839   if (!arg3) {
20840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20841     return 0;
20842   }
20843   arg4 = (Dali::Property::AccessMode)jarg4;
20844   {
20845     try {
20846       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20847     } catch (std::out_of_range& e) {
20848       {
20849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20850       };
20851     } catch (std::exception& e) {
20852       {
20853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20854       };
20855     } catch (Dali::DaliException e) {
20856       {
20857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20858       };
20859     } catch (...) {
20860       {
20861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20862       };
20863     }
20864   }
20865
20866   jresult = result;
20867
20868   //argout typemap for const std::string&
20869
20870   return jresult;
20871 }
20872
20873
20874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20875   void * jresult ;
20876   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20877   Dali::Property::Index arg2 ;
20878   Dali::Property::Value result;
20879
20880   arg1 = (Dali::Handle *)jarg1;
20881   arg2 = (Dali::Property::Index)jarg2;
20882   {
20883     try {
20884       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20885     } catch (std::out_of_range& e) {
20886       {
20887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20888       };
20889     } catch (std::exception& e) {
20890       {
20891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20892       };
20893     } catch (Dali::DaliException e) {
20894       {
20895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20896       };
20897     } catch (...) {
20898       {
20899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20900       };
20901     }
20902   }
20903
20904   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20905   return jresult;
20906 }
20907
20908
20909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20910   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20911   Dali::Property::IndexContainer *arg2 = 0 ;
20912
20913   arg1 = (Dali::Handle *)jarg1;
20914   arg2 = (Dali::Property::IndexContainer *)jarg2;
20915   if (!arg2) {
20916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20917     return ;
20918   }
20919   {
20920     try {
20921       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20922     } catch (std::out_of_range& e) {
20923       {
20924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20925       };
20926     } catch (std::exception& e) {
20927       {
20928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20929       };
20930     } catch (Dali::DaliException e) {
20931       {
20932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20933       };
20934     } catch (...) {
20935       {
20936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20937       };
20938     }
20939   }
20940
20941 }
20942
20943
20944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20945   void * jresult ;
20946   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20947   Dali::Property::Index arg2 ;
20948   Dali::PropertyCondition *arg3 = 0 ;
20949   Dali::PropertyNotification result;
20950
20951   arg1 = (Dali::Handle *)jarg1;
20952   arg2 = (Dali::Property::Index)jarg2;
20953   arg3 = (Dali::PropertyCondition *)jarg3;
20954   if (!arg3) {
20955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20956     return 0;
20957   }
20958   {
20959     try {
20960       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20961     } catch (std::out_of_range& e) {
20962       {
20963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20964       };
20965     } catch (std::exception& e) {
20966       {
20967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20968       };
20969     } catch (Dali::DaliException e) {
20970       {
20971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20972       };
20973     } catch (...) {
20974       {
20975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20976       };
20977     }
20978   }
20979
20980   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20981   return jresult;
20982 }
20983
20984
20985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20986   void * jresult ;
20987   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20988   Dali::Property::Index arg2 ;
20989   int arg3 ;
20990   Dali::PropertyCondition *arg4 = 0 ;
20991   Dali::PropertyNotification result;
20992
20993   arg1 = (Dali::Handle *)jarg1;
20994   arg2 = (Dali::Property::Index)jarg2;
20995   arg3 = (int)jarg3;
20996   arg4 = (Dali::PropertyCondition *)jarg4;
20997   if (!arg4) {
20998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20999     return 0;
21000   }
21001   {
21002     try {
21003       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
21004     } catch (std::out_of_range& e) {
21005       {
21006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21007       };
21008     } catch (std::exception& e) {
21009       {
21010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21011       };
21012     } catch (Dali::DaliException e) {
21013       {
21014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21015       };
21016     } catch (...) {
21017       {
21018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21019       };
21020     }
21021   }
21022
21023   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21024   return jresult;
21025 }
21026
21027
21028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21029   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21030   Dali::PropertyNotification arg2 ;
21031   Dali::PropertyNotification *argp2 ;
21032
21033   arg1 = (Dali::Handle *)jarg1;
21034   argp2 = (Dali::PropertyNotification *)jarg2;
21035   if (!argp2) {
21036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21037     return ;
21038   }
21039   arg2 = *argp2;
21040   {
21041     try {
21042       (arg1)->RemovePropertyNotification(arg2);
21043     } catch (std::out_of_range& e) {
21044       {
21045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21046       };
21047     } catch (std::exception& e) {
21048       {
21049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21050       };
21051     } catch (Dali::DaliException e) {
21052       {
21053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21054       };
21055     } catch (...) {
21056       {
21057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21058       };
21059     }
21060   }
21061
21062 }
21063
21064
21065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21066   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21067
21068   arg1 = (Dali::Handle *)jarg1;
21069   {
21070     try {
21071       (arg1)->RemovePropertyNotifications();
21072     } catch (std::out_of_range& e) {
21073       {
21074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21075       };
21076     } catch (std::exception& e) {
21077       {
21078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21079       };
21080     } catch (Dali::DaliException e) {
21081       {
21082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21083       };
21084     } catch (...) {
21085       {
21086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21087       };
21088     }
21089   }
21090
21091 }
21092
21093
21094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21095   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21096
21097   arg1 = (Dali::Handle *)jarg1;
21098   {
21099     try {
21100       (arg1)->RemoveConstraints();
21101     } catch (std::out_of_range& e) {
21102       {
21103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21104       };
21105     } catch (std::exception& e) {
21106       {
21107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21108       };
21109     } catch (Dali::DaliException e) {
21110       {
21111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21112       };
21113     } catch (...) {
21114       {
21115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21116       };
21117     }
21118   }
21119
21120 }
21121
21122
21123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21124   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21125   unsigned int arg2 ;
21126
21127   arg1 = (Dali::Handle *)jarg1;
21128   arg2 = (unsigned int)jarg2;
21129   {
21130     try {
21131       (arg1)->RemoveConstraints(arg2);
21132     } catch (std::out_of_range& e) {
21133       {
21134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21135       };
21136     } catch (std::exception& e) {
21137       {
21138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21139       };
21140     } catch (Dali::DaliException e) {
21141       {
21142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21143       };
21144     } catch (...) {
21145       {
21146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21147       };
21148     }
21149   }
21150
21151 }
21152
21153
21154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21155   int jresult ;
21156   Dali::Property::Index result;
21157
21158   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21159   jresult = result;
21160   return jresult;
21161 }
21162
21163
21164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21165   void * jresult ;
21166   Dali::Handle result;
21167
21168   {
21169     try {
21170       result = Dali::WeightObject::New();
21171     } catch (std::out_of_range& e) {
21172       {
21173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21174       };
21175     } catch (std::exception& e) {
21176       {
21177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21178       };
21179     } catch (Dali::DaliException e) {
21180       {
21181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21182       };
21183     } catch (...) {
21184       {
21185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21186       };
21187     }
21188   }
21189
21190   jresult = new Dali::Handle((const Dali::Handle &)result);
21191   return jresult;
21192 }
21193
21194
21195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21196   void * jresult ;
21197   Dali::TypeInfo *result = 0 ;
21198
21199   {
21200     try {
21201       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21202     } catch (std::out_of_range& e) {
21203       {
21204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21205       };
21206     } catch (std::exception& e) {
21207       {
21208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21209       };
21210     } catch (Dali::DaliException e) {
21211       {
21212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21213       };
21214     } catch (...) {
21215       {
21216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21217       };
21218     }
21219   }
21220
21221   jresult = (void *)result;
21222   return jresult;
21223 }
21224
21225
21226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21227   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21228
21229   arg1 = (Dali::TypeInfo *)jarg1;
21230   {
21231     try {
21232       delete arg1;
21233     } catch (std::out_of_range& e) {
21234       {
21235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21236       };
21237     } catch (std::exception& e) {
21238       {
21239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21240       };
21241     } catch (Dali::DaliException e) {
21242       {
21243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21244       };
21245     } catch (...) {
21246       {
21247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21248       };
21249     }
21250   }
21251
21252 }
21253
21254
21255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21256   void * jresult ;
21257   Dali::TypeInfo *arg1 = 0 ;
21258   Dali::TypeInfo *result = 0 ;
21259
21260   arg1 = (Dali::TypeInfo *)jarg1;
21261   if (!arg1) {
21262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21263     return 0;
21264   }
21265   {
21266     try {
21267       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21268     } catch (std::out_of_range& e) {
21269       {
21270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21271       };
21272     } catch (std::exception& e) {
21273       {
21274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21275       };
21276     } catch (Dali::DaliException e) {
21277       {
21278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21279       };
21280     } catch (...) {
21281       {
21282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21283       };
21284     }
21285   }
21286
21287   jresult = (void *)result;
21288   return jresult;
21289 }
21290
21291
21292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21293   void * jresult ;
21294   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21295   Dali::TypeInfo *arg2 = 0 ;
21296   Dali::TypeInfo *result = 0 ;
21297
21298   arg1 = (Dali::TypeInfo *)jarg1;
21299   arg2 = (Dali::TypeInfo *)jarg2;
21300   if (!arg2) {
21301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21302     return 0;
21303   }
21304   {
21305     try {
21306       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21307     } catch (std::out_of_range& e) {
21308       {
21309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21310       };
21311     } catch (std::exception& e) {
21312       {
21313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21314       };
21315     } catch (Dali::DaliException e) {
21316       {
21317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21318       };
21319     } catch (...) {
21320       {
21321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21322       };
21323     }
21324   }
21325
21326   jresult = (void *)result;
21327   return jresult;
21328 }
21329
21330
21331 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21332   char * jresult ;
21333   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21334   std::string *result = 0 ;
21335
21336   arg1 = (Dali::TypeInfo *)jarg1;
21337   {
21338     try {
21339       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21340     } catch (std::out_of_range& e) {
21341       {
21342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21343       };
21344     } catch (std::exception& e) {
21345       {
21346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21347       };
21348     } catch (Dali::DaliException e) {
21349       {
21350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21351       };
21352     } catch (...) {
21353       {
21354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21355       };
21356     }
21357   }
21358
21359   jresult = SWIG_csharp_string_callback(result->c_str());
21360   return jresult;
21361 }
21362
21363
21364 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21365   char * jresult ;
21366   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21367   std::string *result = 0 ;
21368
21369   arg1 = (Dali::TypeInfo *)jarg1;
21370   {
21371     try {
21372       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21373     } catch (std::out_of_range& e) {
21374       {
21375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21376       };
21377     } catch (std::exception& e) {
21378       {
21379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21380       };
21381     } catch (Dali::DaliException e) {
21382       {
21383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21384       };
21385     } catch (...) {
21386       {
21387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21388       };
21389     }
21390   }
21391
21392   jresult = SWIG_csharp_string_callback(result->c_str());
21393   return jresult;
21394 }
21395
21396
21397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21398   void * jresult ;
21399   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21400   Dali::BaseHandle result;
21401
21402   arg1 = (Dali::TypeInfo *)jarg1;
21403   {
21404     try {
21405       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21406     } catch (std::out_of_range& e) {
21407       {
21408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21409       };
21410     } catch (std::exception& e) {
21411       {
21412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21413       };
21414     } catch (Dali::DaliException e) {
21415       {
21416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21417       };
21418     } catch (...) {
21419       {
21420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21421       };
21422     }
21423   }
21424
21425   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21426   return jresult;
21427 }
21428
21429
21430 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21431   unsigned long jresult ;
21432   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21433   size_t result;
21434
21435   arg1 = (Dali::TypeInfo *)jarg1;
21436   {
21437     try {
21438       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21439     } catch (std::out_of_range& e) {
21440       {
21441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21442       };
21443     } catch (std::exception& e) {
21444       {
21445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21446       };
21447     } catch (Dali::DaliException e) {
21448       {
21449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21450       };
21451     } catch (...) {
21452       {
21453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21454       };
21455     }
21456   }
21457
21458   jresult = (unsigned long)result;
21459   return jresult;
21460 }
21461
21462
21463 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21464   char * jresult ;
21465   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21466   size_t arg2 ;
21467   std::string result;
21468
21469   arg1 = (Dali::TypeInfo *)jarg1;
21470   arg2 = (size_t)jarg2;
21471   {
21472     try {
21473       result = (arg1)->GetActionName(arg2);
21474     } catch (std::out_of_range& e) {
21475       {
21476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21477       };
21478     } catch (std::exception& e) {
21479       {
21480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21481       };
21482     } catch (Dali::DaliException e) {
21483       {
21484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21485       };
21486     } catch (...) {
21487       {
21488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21489       };
21490     }
21491   }
21492
21493   jresult = SWIG_csharp_string_callback((&result)->c_str());
21494   return jresult;
21495 }
21496
21497
21498 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21499   unsigned long jresult ;
21500   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21501   size_t result;
21502
21503   arg1 = (Dali::TypeInfo *)jarg1;
21504   {
21505     try {
21506       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21507     } catch (std::out_of_range& e) {
21508       {
21509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21510       };
21511     } catch (std::exception& e) {
21512       {
21513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21514       };
21515     } catch (Dali::DaliException e) {
21516       {
21517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21518       };
21519     } catch (...) {
21520       {
21521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21522       };
21523     }
21524   }
21525
21526   jresult = (unsigned long)result;
21527   return jresult;
21528 }
21529
21530
21531 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21532   char * jresult ;
21533   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21534   size_t arg2 ;
21535   std::string result;
21536
21537   arg1 = (Dali::TypeInfo *)jarg1;
21538   arg2 = (size_t)jarg2;
21539   {
21540     try {
21541       result = (arg1)->GetSignalName(arg2);
21542     } catch (std::out_of_range& e) {
21543       {
21544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21545       };
21546     } catch (std::exception& e) {
21547       {
21548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21549       };
21550     } catch (Dali::DaliException e) {
21551       {
21552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21553       };
21554     } catch (...) {
21555       {
21556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21557       };
21558     }
21559   }
21560
21561   jresult = SWIG_csharp_string_callback((&result)->c_str());
21562   return jresult;
21563 }
21564
21565
21566 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21567   unsigned long jresult ;
21568   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21569   size_t result;
21570
21571   arg1 = (Dali::TypeInfo *)jarg1;
21572   {
21573     try {
21574       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21575     } catch (std::out_of_range& e) {
21576       {
21577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21578       };
21579     } catch (std::exception& e) {
21580       {
21581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21582       };
21583     } catch (Dali::DaliException e) {
21584       {
21585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21586       };
21587     } catch (...) {
21588       {
21589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21590       };
21591     }
21592   }
21593
21594   jresult = (unsigned long)result;
21595   return jresult;
21596 }
21597
21598
21599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21600   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21601   Dali::Property::IndexContainer *arg2 = 0 ;
21602
21603   arg1 = (Dali::TypeInfo *)jarg1;
21604   arg2 = (Dali::Property::IndexContainer *)jarg2;
21605   if (!arg2) {
21606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21607     return ;
21608   }
21609   {
21610     try {
21611       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21612     } catch (std::out_of_range& e) {
21613       {
21614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21615       };
21616     } catch (std::exception& e) {
21617       {
21618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21619       };
21620     } catch (Dali::DaliException e) {
21621       {
21622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21623       };
21624     } catch (...) {
21625       {
21626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21627       };
21628     }
21629   }
21630
21631 }
21632
21633
21634 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21635   char * jresult ;
21636   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21637   Dali::Property::Index arg2 ;
21638   std::string *result = 0 ;
21639
21640   arg1 = (Dali::TypeInfo *)jarg1;
21641   arg2 = (Dali::Property::Index)jarg2;
21642   {
21643     try {
21644       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21645     } catch (std::out_of_range& e) {
21646       {
21647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21648       };
21649     } catch (std::exception& e) {
21650       {
21651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21652       };
21653     } catch (Dali::DaliException e) {
21654       {
21655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21656       };
21657     } catch (...) {
21658       {
21659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21660       };
21661     }
21662   }
21663
21664   jresult = SWIG_csharp_string_callback(result->c_str());
21665   return jresult;
21666 }
21667
21668
21669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21670   void * jresult ;
21671   Dali::TypeRegistry result;
21672
21673   {
21674     try {
21675       result = Dali::TypeRegistry::Get();
21676     } catch (std::out_of_range& e) {
21677       {
21678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21679       };
21680     } catch (std::exception& e) {
21681       {
21682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21683       };
21684     } catch (Dali::DaliException e) {
21685       {
21686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21687       };
21688     } catch (...) {
21689       {
21690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21691       };
21692     }
21693   }
21694
21695   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21696   return jresult;
21697 }
21698
21699
21700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21701   void * jresult ;
21702   Dali::TypeRegistry *result = 0 ;
21703
21704   {
21705     try {
21706       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21707     } catch (std::out_of_range& e) {
21708       {
21709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21710       };
21711     } catch (std::exception& e) {
21712       {
21713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21714       };
21715     } catch (Dali::DaliException e) {
21716       {
21717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21718       };
21719     } catch (...) {
21720       {
21721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21722       };
21723     }
21724   }
21725
21726   jresult = (void *)result;
21727   return jresult;
21728 }
21729
21730
21731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21732   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21733
21734   arg1 = (Dali::TypeRegistry *)jarg1;
21735   {
21736     try {
21737       delete arg1;
21738     } catch (std::out_of_range& e) {
21739       {
21740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21741       };
21742     } catch (std::exception& e) {
21743       {
21744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21745       };
21746     } catch (Dali::DaliException e) {
21747       {
21748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21749       };
21750     } catch (...) {
21751       {
21752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21753       };
21754     }
21755   }
21756
21757 }
21758
21759
21760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21761   void * jresult ;
21762   Dali::TypeRegistry *arg1 = 0 ;
21763   Dali::TypeRegistry *result = 0 ;
21764
21765   arg1 = (Dali::TypeRegistry *)jarg1;
21766   if (!arg1) {
21767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21768     return 0;
21769   }
21770   {
21771     try {
21772       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21773     } catch (std::out_of_range& e) {
21774       {
21775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21776       };
21777     } catch (std::exception& e) {
21778       {
21779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21780       };
21781     } catch (Dali::DaliException e) {
21782       {
21783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21784       };
21785     } catch (...) {
21786       {
21787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21788       };
21789     }
21790   }
21791
21792   jresult = (void *)result;
21793   return jresult;
21794 }
21795
21796
21797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21798   void * jresult ;
21799   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21800   Dali::TypeRegistry *arg2 = 0 ;
21801   Dali::TypeRegistry *result = 0 ;
21802
21803   arg1 = (Dali::TypeRegistry *)jarg1;
21804   arg2 = (Dali::TypeRegistry *)jarg2;
21805   if (!arg2) {
21806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21807     return 0;
21808   }
21809   {
21810     try {
21811       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21812     } catch (std::out_of_range& e) {
21813       {
21814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21815       };
21816     } catch (std::exception& e) {
21817       {
21818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21819       };
21820     } catch (Dali::DaliException e) {
21821       {
21822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21823       };
21824     } catch (...) {
21825       {
21826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21827       };
21828     }
21829   }
21830
21831   jresult = (void *)result;
21832   return jresult;
21833 }
21834
21835
21836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21837   void * jresult ;
21838   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21839   std::string *arg2 = 0 ;
21840   Dali::TypeInfo result;
21841
21842   arg1 = (Dali::TypeRegistry *)jarg1;
21843   if (!jarg2) {
21844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21845     return 0;
21846   }
21847   std::string arg2_str(jarg2);
21848   arg2 = &arg2_str;
21849   {
21850     try {
21851       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21852     } catch (std::out_of_range& e) {
21853       {
21854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21855       };
21856     } catch (std::exception& e) {
21857       {
21858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21859       };
21860     } catch (Dali::DaliException e) {
21861       {
21862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21863       };
21864     } catch (...) {
21865       {
21866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21867       };
21868     }
21869   }
21870
21871   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21872
21873   //argout typemap for const std::string&
21874
21875   return jresult;
21876 }
21877
21878
21879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21880   void * jresult ;
21881   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21882   std::type_info *arg2 = 0 ;
21883   Dali::TypeInfo result;
21884
21885   arg1 = (Dali::TypeRegistry *)jarg1;
21886   arg2 = (std::type_info *)jarg2;
21887   if (!arg2) {
21888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21889     return 0;
21890   }
21891   {
21892     try {
21893       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21894     } catch (std::out_of_range& e) {
21895       {
21896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21897       };
21898     } catch (std::exception& e) {
21899       {
21900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21901       };
21902     } catch (Dali::DaliException e) {
21903       {
21904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21905       };
21906     } catch (...) {
21907       {
21908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21909       };
21910     }
21911   }
21912
21913   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21914   return jresult;
21915 }
21916
21917
21918 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21919   unsigned long jresult ;
21920   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21921   size_t result;
21922
21923   arg1 = (Dali::TypeRegistry *)jarg1;
21924   {
21925     try {
21926       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21927     } catch (std::out_of_range& e) {
21928       {
21929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21930       };
21931     } catch (std::exception& e) {
21932       {
21933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21934       };
21935     } catch (Dali::DaliException e) {
21936       {
21937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21938       };
21939     } catch (...) {
21940       {
21941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21942       };
21943     }
21944   }
21945
21946   jresult = (unsigned long)result;
21947   return jresult;
21948 }
21949
21950
21951 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21952   char * jresult ;
21953   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21954   size_t arg2 ;
21955   std::string result;
21956
21957   arg1 = (Dali::TypeRegistry *)jarg1;
21958   arg2 = (size_t)jarg2;
21959   {
21960     try {
21961       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21962     } catch (std::out_of_range& e) {
21963       {
21964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21965       };
21966     } catch (std::exception& e) {
21967       {
21968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21969       };
21970     } catch (Dali::DaliException e) {
21971       {
21972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21973       };
21974     } catch (...) {
21975       {
21976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21977       };
21978     }
21979   }
21980
21981   jresult = SWIG_csharp_string_callback((&result)->c_str());
21982   return jresult;
21983 }
21984
21985
21986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21987   void * jresult ;
21988   std::type_info *arg1 = 0 ;
21989   std::type_info *arg2 = 0 ;
21990   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21991   Dali::TypeRegistration *result = 0 ;
21992
21993   arg1 = (std::type_info *)jarg1;
21994   if (!arg1) {
21995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21996     return 0;
21997   }
21998   arg2 = (std::type_info *)jarg2;
21999   if (!arg2) {
22000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22001     return 0;
22002   }
22003   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22004   {
22005     try {
22006       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22007     } catch (std::out_of_range& e) {
22008       {
22009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22010       };
22011     } catch (std::exception& e) {
22012       {
22013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22014       };
22015     } catch (Dali::DaliException e) {
22016       {
22017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22018       };
22019     } catch (...) {
22020       {
22021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22022       };
22023     }
22024   }
22025
22026   jresult = (void *)result;
22027   return jresult;
22028 }
22029
22030
22031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22032   void * jresult ;
22033   std::type_info *arg1 = 0 ;
22034   std::type_info *arg2 = 0 ;
22035   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22036   bool arg4 ;
22037   Dali::TypeRegistration *result = 0 ;
22038
22039   arg1 = (std::type_info *)jarg1;
22040   if (!arg1) {
22041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22042     return 0;
22043   }
22044   arg2 = (std::type_info *)jarg2;
22045   if (!arg2) {
22046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22047     return 0;
22048   }
22049   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22050   arg4 = jarg4 ? true : false;
22051   {
22052     try {
22053       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22054     } catch (std::out_of_range& e) {
22055       {
22056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22057       };
22058     } catch (std::exception& e) {
22059       {
22060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22061       };
22062     } catch (Dali::DaliException e) {
22063       {
22064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22065       };
22066     } catch (...) {
22067       {
22068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22069       };
22070     }
22071   }
22072
22073   jresult = (void *)result;
22074   return jresult;
22075 }
22076
22077
22078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22079   void * jresult ;
22080   std::string *arg1 = 0 ;
22081   std::type_info *arg2 = 0 ;
22082   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22083   Dali::TypeRegistration *result = 0 ;
22084
22085   if (!jarg1) {
22086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22087     return 0;
22088   }
22089   std::string arg1_str(jarg1);
22090   arg1 = &arg1_str;
22091   arg2 = (std::type_info *)jarg2;
22092   if (!arg2) {
22093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22094     return 0;
22095   }
22096   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22097   {
22098     try {
22099       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22100     } catch (std::out_of_range& e) {
22101       {
22102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22103       };
22104     } catch (std::exception& e) {
22105       {
22106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22107       };
22108     } catch (Dali::DaliException e) {
22109       {
22110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22111       };
22112     } catch (...) {
22113       {
22114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22115       };
22116     }
22117   }
22118
22119   jresult = (void *)result;
22120
22121   //argout typemap for const std::string&
22122
22123   return jresult;
22124 }
22125
22126
22127 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22128   char * jresult ;
22129   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22130   std::string result;
22131
22132   arg1 = (Dali::TypeRegistration *)jarg1;
22133   {
22134     try {
22135       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22136     } catch (std::out_of_range& e) {
22137       {
22138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22139       };
22140     } catch (std::exception& e) {
22141       {
22142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22143       };
22144     } catch (Dali::DaliException e) {
22145       {
22146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22147       };
22148     } catch (...) {
22149       {
22150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22151       };
22152     }
22153   }
22154
22155   jresult = SWIG_csharp_string_callback((&result)->c_str());
22156   return jresult;
22157 }
22158
22159
22160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22161   std::string *arg1 = 0 ;
22162   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22163
22164   if (!jarg1) {
22165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22166     return ;
22167   }
22168   std::string arg1_str(jarg1);
22169   arg1 = &arg1_str;
22170   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22171   {
22172     try {
22173       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22174     } catch (std::out_of_range& e) {
22175       {
22176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22177       };
22178     } catch (std::exception& e) {
22179       {
22180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22181       };
22182     } catch (Dali::DaliException e) {
22183       {
22184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22185       };
22186     } catch (...) {
22187       {
22188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22189       };
22190     }
22191   }
22192
22193
22194   //argout typemap for const std::string&
22195
22196 }
22197
22198
22199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22200   std::string *arg1 = 0 ;
22201   std::string *arg2 = 0 ;
22202   int arg3 ;
22203   Dali::Property::Type arg4 ;
22204   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22205   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22206
22207   if (!jarg1) {
22208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22209     return ;
22210   }
22211   std::string arg1_str(jarg1);
22212   arg1 = &arg1_str;
22213   if (!jarg2) {
22214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22215     return ;
22216   }
22217   std::string arg2_str(jarg2);
22218   arg2 = &arg2_str;
22219   arg3 = (int)jarg3;
22220   arg4 = (Dali::Property::Type)jarg4;
22221   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22222   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22223   {
22224     try {
22225       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22226     } catch (std::out_of_range& e) {
22227       {
22228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22229       };
22230     } catch (std::exception& e) {
22231       {
22232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22233       };
22234     } catch (Dali::DaliException e) {
22235       {
22236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22237       };
22238     } catch (...) {
22239       {
22240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22241       };
22242     }
22243   }
22244
22245
22246   //argout typemap for const std::string&
22247
22248
22249   //argout typemap for const std::string&
22250
22251 }
22252
22253
22254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22255   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22256
22257   arg1 = (Dali::TypeRegistration *)jarg1;
22258   {
22259     try {
22260       delete arg1;
22261     } catch (std::out_of_range& e) {
22262       {
22263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22264       };
22265     } catch (std::exception& e) {
22266       {
22267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22268       };
22269     } catch (Dali::DaliException e) {
22270       {
22271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22272       };
22273     } catch (...) {
22274       {
22275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22276       };
22277     }
22278   }
22279
22280 }
22281
22282
22283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22284   void * jresult ;
22285   Dali::TypeRegistration *arg1 = 0 ;
22286   std::string *arg2 = 0 ;
22287   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22288   Dali::SignalConnectorType *result = 0 ;
22289
22290   arg1 = (Dali::TypeRegistration *)jarg1;
22291   if (!arg1) {
22292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22293     return 0;
22294   }
22295   if (!jarg2) {
22296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22297     return 0;
22298   }
22299   std::string arg2_str(jarg2);
22300   arg2 = &arg2_str;
22301   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22302   {
22303     try {
22304       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22305     } catch (std::out_of_range& e) {
22306       {
22307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22308       };
22309     } catch (std::exception& e) {
22310       {
22311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22312       };
22313     } catch (Dali::DaliException e) {
22314       {
22315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22316       };
22317     } catch (...) {
22318       {
22319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22320       };
22321     }
22322   }
22323
22324   jresult = (void *)result;
22325
22326   //argout typemap for const std::string&
22327
22328   return jresult;
22329 }
22330
22331
22332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22333   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22334
22335   arg1 = (Dali::SignalConnectorType *)jarg1;
22336   {
22337     try {
22338       delete arg1;
22339     } catch (std::out_of_range& e) {
22340       {
22341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22342       };
22343     } catch (std::exception& e) {
22344       {
22345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22346       };
22347     } catch (Dali::DaliException e) {
22348       {
22349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22350       };
22351     } catch (...) {
22352       {
22353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22354       };
22355     }
22356   }
22357
22358 }
22359
22360
22361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22362   void * jresult ;
22363   Dali::TypeRegistration *arg1 = 0 ;
22364   std::string *arg2 = 0 ;
22365   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22366   Dali::TypeAction *result = 0 ;
22367
22368   arg1 = (Dali::TypeRegistration *)jarg1;
22369   if (!arg1) {
22370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22371     return 0;
22372   }
22373   if (!jarg2) {
22374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22375     return 0;
22376   }
22377   std::string arg2_str(jarg2);
22378   arg2 = &arg2_str;
22379   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22380   {
22381     try {
22382       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22383     } catch (std::out_of_range& e) {
22384       {
22385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22386       };
22387     } catch (std::exception& e) {
22388       {
22389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22390       };
22391     } catch (Dali::DaliException e) {
22392       {
22393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22394       };
22395     } catch (...) {
22396       {
22397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22398       };
22399     }
22400   }
22401
22402   jresult = (void *)result;
22403
22404   //argout typemap for const std::string&
22405
22406   return jresult;
22407 }
22408
22409
22410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22411   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22412
22413   arg1 = (Dali::TypeAction *)jarg1;
22414   {
22415     try {
22416       delete arg1;
22417     } catch (std::out_of_range& e) {
22418       {
22419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22420       };
22421     } catch (std::exception& e) {
22422       {
22423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22424       };
22425     } catch (Dali::DaliException e) {
22426       {
22427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22428       };
22429     } catch (...) {
22430       {
22431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22432       };
22433     }
22434   }
22435
22436 }
22437
22438
22439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22440   void * jresult ;
22441   Dali::TypeRegistration *arg1 = 0 ;
22442   std::string *arg2 = 0 ;
22443   Dali::Property::Index arg3 ;
22444   Dali::Property::Type arg4 ;
22445   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22446   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22447   Dali::PropertyRegistration *result = 0 ;
22448
22449   arg1 = (Dali::TypeRegistration *)jarg1;
22450   if (!arg1) {
22451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22452     return 0;
22453   }
22454   if (!jarg2) {
22455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22456     return 0;
22457   }
22458   std::string arg2_str(jarg2);
22459   arg2 = &arg2_str;
22460   arg3 = (Dali::Property::Index)jarg3;
22461   arg4 = (Dali::Property::Type)jarg4;
22462   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22463   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22464   {
22465     try {
22466       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22467     } catch (std::out_of_range& e) {
22468       {
22469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22470       };
22471     } catch (std::exception& e) {
22472       {
22473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22474       };
22475     } catch (Dali::DaliException e) {
22476       {
22477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22478       };
22479     } catch (...) {
22480       {
22481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22482       };
22483     }
22484   }
22485
22486   jresult = (void *)result;
22487
22488   //argout typemap for const std::string&
22489
22490   return jresult;
22491 }
22492
22493
22494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22495   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22496
22497   arg1 = (Dali::PropertyRegistration *)jarg1;
22498   {
22499     try {
22500       delete arg1;
22501     } catch (std::out_of_range& e) {
22502       {
22503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22504       };
22505     } catch (std::exception& e) {
22506       {
22507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22508       };
22509     } catch (Dali::DaliException e) {
22510       {
22511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22512       };
22513     } catch (...) {
22514       {
22515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22516       };
22517     }
22518   }
22519
22520 }
22521
22522
22523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22524   void * jresult ;
22525   Dali::TypeRegistration *arg1 = 0 ;
22526   std::string *arg2 = 0 ;
22527   Dali::Property::Index arg3 ;
22528   Dali::Property::Type arg4 ;
22529   Dali::AnimatablePropertyRegistration *result = 0 ;
22530
22531   arg1 = (Dali::TypeRegistration *)jarg1;
22532   if (!arg1) {
22533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22534     return 0;
22535   }
22536   if (!jarg2) {
22537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22538     return 0;
22539   }
22540   std::string arg2_str(jarg2);
22541   arg2 = &arg2_str;
22542   arg3 = (Dali::Property::Index)jarg3;
22543   arg4 = (Dali::Property::Type)jarg4;
22544   {
22545     try {
22546       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22547     } catch (std::out_of_range& e) {
22548       {
22549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22550       };
22551     } catch (std::exception& e) {
22552       {
22553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22554       };
22555     } catch (Dali::DaliException e) {
22556       {
22557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22558       };
22559     } catch (...) {
22560       {
22561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22562       };
22563     }
22564   }
22565
22566   jresult = (void *)result;
22567
22568   //argout typemap for const std::string&
22569
22570   return jresult;
22571 }
22572
22573
22574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22575   void * jresult ;
22576   Dali::TypeRegistration *arg1 = 0 ;
22577   std::string *arg2 = 0 ;
22578   Dali::Property::Index arg3 ;
22579   Dali::Property::Value *arg4 = 0 ;
22580   Dali::AnimatablePropertyRegistration *result = 0 ;
22581
22582   arg1 = (Dali::TypeRegistration *)jarg1;
22583   if (!arg1) {
22584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22585     return 0;
22586   }
22587   if (!jarg2) {
22588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22589     return 0;
22590   }
22591   std::string arg2_str(jarg2);
22592   arg2 = &arg2_str;
22593   arg3 = (Dali::Property::Index)jarg3;
22594   arg4 = (Dali::Property::Value *)jarg4;
22595   if (!arg4) {
22596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22597     return 0;
22598   }
22599   {
22600     try {
22601       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22602     } catch (std::out_of_range& e) {
22603       {
22604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22605       };
22606     } catch (std::exception& e) {
22607       {
22608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22609       };
22610     } catch (Dali::DaliException e) {
22611       {
22612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22613       };
22614     } catch (...) {
22615       {
22616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22617       };
22618     }
22619   }
22620
22621   jresult = (void *)result;
22622
22623   //argout typemap for const std::string&
22624
22625   return jresult;
22626 }
22627
22628
22629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22630   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22631
22632   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22633   {
22634     try {
22635       delete arg1;
22636     } catch (std::out_of_range& e) {
22637       {
22638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22639       };
22640     } catch (std::exception& e) {
22641       {
22642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22643       };
22644     } catch (Dali::DaliException e) {
22645       {
22646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22647       };
22648     } catch (...) {
22649       {
22650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22651       };
22652     }
22653   }
22654
22655 }
22656
22657
22658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22659   void * jresult ;
22660   Dali::TypeRegistration *arg1 = 0 ;
22661   std::string *arg2 = 0 ;
22662   Dali::Property::Index arg3 ;
22663   Dali::Property::Index arg4 ;
22664   unsigned int arg5 ;
22665   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22666
22667   arg1 = (Dali::TypeRegistration *)jarg1;
22668   if (!arg1) {
22669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22670     return 0;
22671   }
22672   if (!jarg2) {
22673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22674     return 0;
22675   }
22676   std::string arg2_str(jarg2);
22677   arg2 = &arg2_str;
22678   arg3 = (Dali::Property::Index)jarg3;
22679   arg4 = (Dali::Property::Index)jarg4;
22680   arg5 = (unsigned int)jarg5;
22681   {
22682     try {
22683       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22684     } catch (std::out_of_range& e) {
22685       {
22686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22687       };
22688     } catch (std::exception& e) {
22689       {
22690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22691       };
22692     } catch (Dali::DaliException e) {
22693       {
22694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22695       };
22696     } catch (...) {
22697       {
22698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22699       };
22700     }
22701   }
22702
22703   jresult = (void *)result;
22704
22705   //argout typemap for const std::string&
22706
22707   return jresult;
22708 }
22709
22710
22711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22712   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22713
22714   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22715   {
22716     try {
22717       delete arg1;
22718     } catch (std::out_of_range& e) {
22719       {
22720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22721       };
22722     } catch (std::exception& e) {
22723       {
22724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22725       };
22726     } catch (Dali::DaliException e) {
22727       {
22728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22729       };
22730     } catch (...) {
22731       {
22732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22733       };
22734     }
22735   }
22736
22737 }
22738
22739
22740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22741   void * jresult ;
22742   Dali::TypeRegistration *arg1 = 0 ;
22743   std::string *arg2 = 0 ;
22744   Dali::Property::Index arg3 ;
22745   Dali::Property::Type arg4 ;
22746   Dali::ChildPropertyRegistration *result = 0 ;
22747
22748   arg1 = (Dali::TypeRegistration *)jarg1;
22749   if (!arg1) {
22750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22751     return 0;
22752   }
22753   if (!jarg2) {
22754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22755     return 0;
22756   }
22757   std::string arg2_str(jarg2);
22758   arg2 = &arg2_str;
22759   arg3 = (Dali::Property::Index)jarg3;
22760   arg4 = (Dali::Property::Type)jarg4;
22761   {
22762     try {
22763       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22764     } catch (std::out_of_range& e) {
22765       {
22766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22767       };
22768     } catch (std::exception& e) {
22769       {
22770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22771       };
22772     } catch (Dali::DaliException e) {
22773       {
22774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22775       };
22776     } catch (...) {
22777       {
22778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22779       };
22780     }
22781   }
22782
22783   jresult = (void *)result;
22784
22785   //argout typemap for const std::string&
22786
22787   return jresult;
22788 }
22789
22790
22791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22792   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22793
22794   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22795   {
22796     try {
22797       delete arg1;
22798     } catch (std::out_of_range& e) {
22799       {
22800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22801       };
22802     } catch (std::exception& e) {
22803       {
22804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22805       };
22806     } catch (Dali::DaliException e) {
22807       {
22808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22809       };
22810     } catch (...) {
22811       {
22812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22813       };
22814     }
22815   }
22816
22817 }
22818
22819
22820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22821   unsigned int jresult ;
22822   std::string *arg1 = 0 ;
22823   std::type_info *arg2 = 0 ;
22824   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22825   bool result;
22826
22827   if (!jarg1) {
22828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22829     return 0;
22830   }
22831   std::string arg1_str(jarg1);
22832   arg1 = &arg1_str;
22833   arg2 = (std::type_info *)jarg2;
22834   if (!arg2) {
22835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22836     return 0;
22837   }
22838   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22839   {
22840     try {
22841       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22842     } catch (std::out_of_range& e) {
22843       {
22844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22845       };
22846     } catch (std::exception& e) {
22847       {
22848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22849       };
22850     } catch (Dali::DaliException e) {
22851       {
22852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22853       };
22854     } catch (...) {
22855       {
22856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22857       };
22858     }
22859   }
22860
22861   jresult = result;
22862
22863   //argout typemap for const std::string&
22864
22865   return jresult;
22866 }
22867
22868
22869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22870   unsigned int jresult ;
22871   std::string *arg1 = 0 ;
22872   std::string *arg2 = 0 ;
22873   Dali::Property::Index arg3 ;
22874   Dali::Property::Type arg4 ;
22875   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22876   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22877   bool result;
22878
22879   if (!jarg1) {
22880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22881     return 0;
22882   }
22883   std::string arg1_str(jarg1);
22884   arg1 = &arg1_str;
22885   if (!jarg2) {
22886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22887     return 0;
22888   }
22889   std::string arg2_str(jarg2);
22890   arg2 = &arg2_str;
22891   arg3 = (Dali::Property::Index)jarg3;
22892   arg4 = (Dali::Property::Type)jarg4;
22893   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22894   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22895   {
22896     try {
22897       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22898     } catch (std::out_of_range& e) {
22899       {
22900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22901       };
22902     } catch (std::exception& e) {
22903       {
22904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22905       };
22906     } catch (Dali::DaliException e) {
22907       {
22908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22909       };
22910     } catch (...) {
22911       {
22912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22913       };
22914     }
22915   }
22916
22917   jresult = result;
22918
22919   //argout typemap for const std::string&
22920
22921
22922   //argout typemap for const std::string&
22923
22924   return jresult;
22925 }
22926
22927
22928 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22929   float jresult ;
22930   float result;
22931
22932   result = (float)(float)Dali::ParentOrigin::TOP;
22933   jresult = result;
22934   return jresult;
22935 }
22936
22937
22938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22939   float jresult ;
22940   float result;
22941
22942   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22943   jresult = result;
22944   return jresult;
22945 }
22946
22947
22948 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22949   float jresult ;
22950   float result;
22951
22952   result = (float)(float)Dali::ParentOrigin::LEFT;
22953   jresult = result;
22954   return jresult;
22955 }
22956
22957
22958 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22959   float jresult ;
22960   float result;
22961
22962   result = (float)(float)Dali::ParentOrigin::RIGHT;
22963   jresult = result;
22964   return jresult;
22965 }
22966
22967
22968 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22969   float jresult ;
22970   float result;
22971
22972   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22973   jresult = result;
22974   return jresult;
22975 }
22976
22977
22978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22979   void * jresult ;
22980   Dali::Vector3 *result = 0 ;
22981
22982   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22983   jresult = (void *)result;
22984   return jresult;
22985 }
22986
22987
22988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22989   void * jresult ;
22990   Dali::Vector3 *result = 0 ;
22991
22992   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22993   jresult = (void *)result;
22994   return jresult;
22995 }
22996
22997
22998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22999   void * jresult ;
23000   Dali::Vector3 *result = 0 ;
23001
23002   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23003   jresult = (void *)result;
23004   return jresult;
23005 }
23006
23007
23008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23009   void * jresult ;
23010   Dali::Vector3 *result = 0 ;
23011
23012   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23013   jresult = (void *)result;
23014   return jresult;
23015 }
23016
23017
23018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23019   void * jresult ;
23020   Dali::Vector3 *result = 0 ;
23021
23022   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23023   jresult = (void *)result;
23024   return jresult;
23025 }
23026
23027
23028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23029   void * jresult ;
23030   Dali::Vector3 *result = 0 ;
23031
23032   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23033   jresult = (void *)result;
23034   return jresult;
23035 }
23036
23037
23038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23039   void * jresult ;
23040   Dali::Vector3 *result = 0 ;
23041
23042   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23043   jresult = (void *)result;
23044   return jresult;
23045 }
23046
23047
23048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23049   void * jresult ;
23050   Dali::Vector3 *result = 0 ;
23051
23052   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23053   jresult = (void *)result;
23054   return jresult;
23055 }
23056
23057
23058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23059   void * jresult ;
23060   Dali::Vector3 *result = 0 ;
23061
23062   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23063   jresult = (void *)result;
23064   return jresult;
23065 }
23066
23067
23068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23069   float jresult ;
23070   float result;
23071
23072   result = (float)(float)Dali::AnchorPoint::TOP;
23073   jresult = result;
23074   return jresult;
23075 }
23076
23077
23078 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23079   float jresult ;
23080   float result;
23081
23082   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23083   jresult = result;
23084   return jresult;
23085 }
23086
23087
23088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23089   float jresult ;
23090   float result;
23091
23092   result = (float)(float)Dali::AnchorPoint::LEFT;
23093   jresult = result;
23094   return jresult;
23095 }
23096
23097
23098 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23099   float jresult ;
23100   float result;
23101
23102   result = (float)(float)Dali::AnchorPoint::RIGHT;
23103   jresult = result;
23104   return jresult;
23105 }
23106
23107
23108 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23109   float jresult ;
23110   float result;
23111
23112   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23113   jresult = result;
23114   return jresult;
23115 }
23116
23117
23118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23119   void * jresult ;
23120   Dali::Vector3 *result = 0 ;
23121
23122   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23123   jresult = (void *)result;
23124   return jresult;
23125 }
23126
23127
23128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23129   void * jresult ;
23130   Dali::Vector3 *result = 0 ;
23131
23132   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23133   jresult = (void *)result;
23134   return jresult;
23135 }
23136
23137
23138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23139   void * jresult ;
23140   Dali::Vector3 *result = 0 ;
23141
23142   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23143   jresult = (void *)result;
23144   return jresult;
23145 }
23146
23147
23148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23149   void * jresult ;
23150   Dali::Vector3 *result = 0 ;
23151
23152   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23153   jresult = (void *)result;
23154   return jresult;
23155 }
23156
23157
23158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23159   void * jresult ;
23160   Dali::Vector3 *result = 0 ;
23161
23162   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23163   jresult = (void *)result;
23164   return jresult;
23165 }
23166
23167
23168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23169   void * jresult ;
23170   Dali::Vector3 *result = 0 ;
23171
23172   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23173   jresult = (void *)result;
23174   return jresult;
23175 }
23176
23177
23178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23179   void * jresult ;
23180   Dali::Vector3 *result = 0 ;
23181
23182   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23183   jresult = (void *)result;
23184   return jresult;
23185 }
23186
23187
23188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23189   void * jresult ;
23190   Dali::Vector3 *result = 0 ;
23191
23192   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23193   jresult = (void *)result;
23194   return jresult;
23195 }
23196
23197
23198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23199   void * jresult ;
23200   Dali::Vector3 *result = 0 ;
23201
23202   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23203   jresult = (void *)result;
23204   return jresult;
23205 }
23206
23207
23208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23209   void * jresult ;
23210   Dali::Vector4 *result = 0 ;
23211
23212   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23213   jresult = (void *)result;
23214   return jresult;
23215 }
23216
23217
23218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23219   void * jresult ;
23220   Dali::Vector4 *result = 0 ;
23221
23222   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23223   jresult = (void *)result;
23224   return jresult;
23225 }
23226
23227
23228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23229   void * jresult ;
23230   Dali::Vector4 *result = 0 ;
23231
23232   result = (Dali::Vector4 *)&Dali::Color::RED;
23233   jresult = (void *)result;
23234   return jresult;
23235 }
23236
23237
23238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23239   void * jresult ;
23240   Dali::Vector4 *result = 0 ;
23241
23242   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23243   jresult = (void *)result;
23244   return jresult;
23245 }
23246
23247
23248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23249   void * jresult ;
23250   Dali::Vector4 *result = 0 ;
23251
23252   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23253   jresult = (void *)result;
23254   return jresult;
23255 }
23256
23257
23258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23259   void * jresult ;
23260   Dali::Vector4 *result = 0 ;
23261
23262   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23263   jresult = (void *)result;
23264   return jresult;
23265 }
23266
23267
23268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23269   void * jresult ;
23270   Dali::Vector4 *result = 0 ;
23271
23272   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23273   jresult = (void *)result;
23274   return jresult;
23275 }
23276
23277
23278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23279   void * jresult ;
23280   Dali::Vector4 *result = 0 ;
23281
23282   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23283   jresult = (void *)result;
23284   return jresult;
23285 }
23286
23287
23288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23289   void * jresult ;
23290   Dali::Vector4 *result = 0 ;
23291
23292   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23293   jresult = (void *)result;
23294   return jresult;
23295 }
23296
23297
23298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23299   float jresult ;
23300   float result;
23301
23302   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23303   jresult = result;
23304   return jresult;
23305 }
23306
23307
23308 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23309   float jresult ;
23310   float result;
23311
23312   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23313   jresult = result;
23314   return jresult;
23315 }
23316
23317
23318 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23319   float jresult ;
23320   float result;
23321
23322   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23323   jresult = result;
23324   return jresult;
23325 }
23326
23327
23328 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23329   float jresult ;
23330   float result;
23331
23332   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23333   jresult = result;
23334   return jresult;
23335 }
23336
23337
23338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23339   float jresult ;
23340   float result;
23341
23342   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23343   jresult = result;
23344   return jresult;
23345 }
23346
23347
23348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23349   float jresult ;
23350   float result;
23351
23352   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23353   jresult = result;
23354   return jresult;
23355 }
23356
23357
23358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23359   float jresult ;
23360   float result;
23361
23362   result = (float)(float)Dali::Math::PI;
23363   jresult = result;
23364   return jresult;
23365 }
23366
23367
23368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23369   float jresult ;
23370   float result;
23371
23372   result = (float)(float)Dali::Math::PI_2;
23373   jresult = result;
23374   return jresult;
23375 }
23376
23377
23378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23379   float jresult ;
23380   float result;
23381
23382   result = (float)(float)Dali::Math::PI_4;
23383   jresult = result;
23384   return jresult;
23385 }
23386
23387
23388 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23389   float jresult ;
23390   float result;
23391
23392   result = (float)(float)Dali::Math::PI_OVER_180;
23393   jresult = result;
23394   return jresult;
23395 }
23396
23397
23398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23399   float jresult ;
23400   float result;
23401
23402   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23403   jresult = result;
23404   return jresult;
23405 }
23406
23407
23408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23409   int jresult ;
23410   Dali::ResizePolicy::Type result;
23411
23412   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23413   jresult = (int)result;
23414   return jresult;
23415 }
23416
23417
23418 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23419   unsigned long jresult ;
23420   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23421   Dali::VectorBase::SizeType result;
23422
23423   arg1 = (Dali::VectorBase *)jarg1;
23424   {
23425     try {
23426       result = ((Dali::VectorBase const *)arg1)->Count();
23427     } catch (std::out_of_range& e) {
23428       {
23429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23430       };
23431     } catch (std::exception& e) {
23432       {
23433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23434       };
23435     } catch (Dali::DaliException e) {
23436       {
23437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23438       };
23439     } catch (...) {
23440       {
23441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23442       };
23443     }
23444   }
23445
23446   jresult = (unsigned long)result;
23447   return jresult;
23448 }
23449
23450
23451 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23452   unsigned long jresult ;
23453   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23454   Dali::VectorBase::SizeType result;
23455
23456   arg1 = (Dali::VectorBase *)jarg1;
23457   {
23458     try {
23459       result = ((Dali::VectorBase const *)arg1)->Size();
23460     } catch (std::out_of_range& e) {
23461       {
23462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23463       };
23464     } catch (std::exception& e) {
23465       {
23466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23467       };
23468     } catch (Dali::DaliException e) {
23469       {
23470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23471       };
23472     } catch (...) {
23473       {
23474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23475       };
23476     }
23477   }
23478
23479   jresult = (unsigned long)result;
23480   return jresult;
23481 }
23482
23483
23484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23485   unsigned int jresult ;
23486   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23487   bool result;
23488
23489   arg1 = (Dali::VectorBase *)jarg1;
23490   {
23491     try {
23492       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23493     } catch (std::out_of_range& e) {
23494       {
23495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23496       };
23497     } catch (std::exception& e) {
23498       {
23499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23500       };
23501     } catch (Dali::DaliException e) {
23502       {
23503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23504       };
23505     } catch (...) {
23506       {
23507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23508       };
23509     }
23510   }
23511
23512   jresult = result;
23513   return jresult;
23514 }
23515
23516
23517 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23518   unsigned long jresult ;
23519   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23520   Dali::VectorBase::SizeType result;
23521
23522   arg1 = (Dali::VectorBase *)jarg1;
23523   {
23524     try {
23525       result = ((Dali::VectorBase const *)arg1)->Capacity();
23526     } catch (std::out_of_range& e) {
23527       {
23528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23529       };
23530     } catch (std::exception& e) {
23531       {
23532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23533       };
23534     } catch (Dali::DaliException e) {
23535       {
23536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23537       };
23538     } catch (...) {
23539       {
23540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23541       };
23542     }
23543   }
23544
23545   jresult = (unsigned long)result;
23546   return jresult;
23547 }
23548
23549
23550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23551   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23552
23553   arg1 = (Dali::VectorBase *)jarg1;
23554   {
23555     try {
23556       (arg1)->Release();
23557     } catch (std::out_of_range& e) {
23558       {
23559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23560       };
23561     } catch (std::exception& e) {
23562       {
23563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23564       };
23565     } catch (Dali::DaliException e) {
23566       {
23567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23568       };
23569     } catch (...) {
23570       {
23571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23572       };
23573     }
23574   }
23575
23576 }
23577
23578
23579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23580   int jresult ;
23581   Dali::Pixel::Format result;
23582
23583   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23584   jresult = (int)result;
23585   return jresult;
23586 }
23587
23588
23589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23590   int jresult ;
23591   Dali::Pixel::Format result;
23592
23593   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23594   jresult = (int)result;
23595   return jresult;
23596 }
23597
23598
23599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23600   unsigned int jresult ;
23601   Dali::Pixel::Format arg1 ;
23602   bool result;
23603
23604   arg1 = (Dali::Pixel::Format)jarg1;
23605   {
23606     try {
23607       result = (bool)Dali::Pixel::HasAlpha(arg1);
23608     } catch (std::out_of_range& e) {
23609       {
23610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23611       };
23612     } catch (std::exception& e) {
23613       {
23614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23615       };
23616     } catch (Dali::DaliException e) {
23617       {
23618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23619       };
23620     } catch (...) {
23621       {
23622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23623       };
23624     }
23625   }
23626
23627   jresult = result;
23628   return jresult;
23629 }
23630
23631
23632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23633   unsigned int jresult ;
23634   Dali::Pixel::Format arg1 ;
23635   unsigned int result;
23636
23637   arg1 = (Dali::Pixel::Format)jarg1;
23638   {
23639     try {
23640       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23641     } catch (std::out_of_range& e) {
23642       {
23643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23644       };
23645     } catch (std::exception& e) {
23646       {
23647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23648       };
23649     } catch (Dali::DaliException e) {
23650       {
23651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23652       };
23653     } catch (...) {
23654       {
23655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23656       };
23657     }
23658   }
23659
23660   jresult = result;
23661   return jresult;
23662 }
23663
23664
23665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23666   Dali::Pixel::Format arg1 ;
23667   int *arg2 = 0 ;
23668   int *arg3 = 0 ;
23669
23670   arg1 = (Dali::Pixel::Format)jarg1;
23671   arg2 = (int *)jarg2;
23672   if (!arg2) {
23673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23674     return ;
23675   }
23676   arg3 = (int *)jarg3;
23677   if (!arg3) {
23678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23679     return ;
23680   }
23681   {
23682     try {
23683       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23684     } catch (std::out_of_range& e) {
23685       {
23686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23687       };
23688     } catch (std::exception& e) {
23689       {
23690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23691       };
23692     } catch (Dali::DaliException e) {
23693       {
23694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23695       };
23696     } catch (...) {
23697       {
23698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23699       };
23700     }
23701   }
23702
23703 }
23704
23705
23706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23707   void * jresult ;
23708   unsigned char *arg1 = (unsigned char *) 0 ;
23709   unsigned int arg2 ;
23710   unsigned int arg3 ;
23711   unsigned int arg4 ;
23712   Dali::Pixel::Format arg5 ;
23713   Dali::PixelData::ReleaseFunction arg6 ;
23714   Dali::PixelData result;
23715
23716   arg1 = jarg1;
23717   arg2 = (unsigned int)jarg2;
23718   arg3 = (unsigned int)jarg3;
23719   arg4 = (unsigned int)jarg4;
23720   arg5 = (Dali::Pixel::Format)jarg5;
23721   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23722   {
23723     try {
23724       auto pixelBuffer = new unsigned char[jarg2];
23725       memcpy( pixelBuffer, arg1, arg2);
23726       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23727     } catch (std::out_of_range& e) {
23728       {
23729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23730       };
23731     } catch (std::exception& e) {
23732       {
23733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23734       };
23735     } catch (Dali::DaliException e) {
23736       {
23737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23738       };
23739     } catch (...) {
23740       {
23741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23742       };
23743     }
23744   }
23745
23746   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23747
23748
23749   return jresult;
23750 }
23751
23752
23753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
23754   void * jresult ;
23755   Dali::PixelData *result = 0 ;
23756
23757   {
23758     try {
23759       result = (Dali::PixelData *)new Dali::PixelData();
23760     } catch (std::out_of_range& e) {
23761       {
23762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23763       };
23764     } catch (std::exception& e) {
23765       {
23766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23767       };
23768     } catch (Dali::DaliException e) {
23769       {
23770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23771       };
23772     } catch (...) {
23773       {
23774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23775       };
23776     }
23777   }
23778
23779   jresult = (void *)result;
23780   return jresult;
23781 }
23782
23783
23784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
23785   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23786
23787   arg1 = (Dali::PixelData *)jarg1;
23788   {
23789     try {
23790       delete arg1;
23791     } catch (std::out_of_range& e) {
23792       {
23793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23794       };
23795     } catch (std::exception& e) {
23796       {
23797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23798       };
23799     } catch (Dali::DaliException e) {
23800       {
23801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23802       };
23803     } catch (...) {
23804       {
23805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23806       };
23807     }
23808   }
23809
23810 }
23811
23812
23813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
23814   void * jresult ;
23815   Dali::PixelData *arg1 = 0 ;
23816   Dali::PixelData *result = 0 ;
23817
23818   arg1 = (Dali::PixelData *)jarg1;
23819   if (!arg1) {
23820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23821     return 0;
23822   }
23823   {
23824     try {
23825       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
23826     } catch (std::out_of_range& e) {
23827       {
23828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23829       };
23830     } catch (std::exception& e) {
23831       {
23832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23833       };
23834     } catch (Dali::DaliException e) {
23835       {
23836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23837       };
23838     } catch (...) {
23839       {
23840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23841       };
23842     }
23843   }
23844
23845   jresult = (void *)result;
23846   return jresult;
23847 }
23848
23849
23850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
23851   void * jresult ;
23852   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23853   Dali::PixelData *arg2 = 0 ;
23854   Dali::PixelData *result = 0 ;
23855
23856   arg1 = (Dali::PixelData *)jarg1;
23857   arg2 = (Dali::PixelData *)jarg2;
23858   if (!arg2) {
23859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23860     return 0;
23861   }
23862   {
23863     try {
23864       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
23865     } catch (std::out_of_range& e) {
23866       {
23867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23868       };
23869     } catch (std::exception& e) {
23870       {
23871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23872       };
23873     } catch (Dali::DaliException e) {
23874       {
23875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23876       };
23877     } catch (...) {
23878       {
23879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23880       };
23881     }
23882   }
23883
23884   jresult = (void *)result;
23885   return jresult;
23886 }
23887
23888
23889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
23890   unsigned int jresult ;
23891   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23892   unsigned int result;
23893
23894   arg1 = (Dali::PixelData *)jarg1;
23895   {
23896     try {
23897       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
23898     } catch (std::out_of_range& e) {
23899       {
23900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23901       };
23902     } catch (std::exception& e) {
23903       {
23904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23905       };
23906     } catch (Dali::DaliException e) {
23907       {
23908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23909       };
23910     } catch (...) {
23911       {
23912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23913       };
23914     }
23915   }
23916
23917   jresult = result;
23918   return jresult;
23919 }
23920
23921
23922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
23923   unsigned int jresult ;
23924   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23925   unsigned int result;
23926
23927   arg1 = (Dali::PixelData *)jarg1;
23928   {
23929     try {
23930       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
23931     } catch (std::out_of_range& e) {
23932       {
23933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23934       };
23935     } catch (std::exception& e) {
23936       {
23937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23938       };
23939     } catch (Dali::DaliException e) {
23940       {
23941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23942       };
23943     } catch (...) {
23944       {
23945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23946       };
23947     }
23948   }
23949
23950   jresult = result;
23951   return jresult;
23952 }
23953
23954
23955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
23956   int jresult ;
23957   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23958   Dali::Pixel::Format result;
23959
23960   arg1 = (Dali::PixelData *)jarg1;
23961   {
23962     try {
23963       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
23964     } catch (std::out_of_range& e) {
23965       {
23966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23967       };
23968     } catch (std::exception& e) {
23969       {
23970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23971       };
23972     } catch (Dali::DaliException e) {
23973       {
23974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23975       };
23976     } catch (...) {
23977       {
23978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23979       };
23980     }
23981   }
23982
23983   jresult = (int)result;
23984   return jresult;
23985 }
23986
23987
23988 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
23989   unsigned int jresult ;
23990   unsigned int result;
23991
23992   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
23993   jresult = result;
23994   return jresult;
23995 }
23996
23997
23998 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
23999   unsigned int jresult ;
24000   unsigned int result;
24001
24002   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24003   jresult = result;
24004   return jresult;
24005 }
24006
24007
24008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24009   unsigned int jresult ;
24010   unsigned int result;
24011
24012   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24013   jresult = result;
24014   return jresult;
24015 }
24016
24017
24018 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24019   unsigned int jresult ;
24020   unsigned int result;
24021
24022   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24023   jresult = result;
24024   return jresult;
24025 }
24026
24027
24028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24029   unsigned int jresult ;
24030   unsigned int result;
24031
24032   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24033   jresult = result;
24034   return jresult;
24035 }
24036
24037
24038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24039   unsigned int jresult ;
24040   unsigned int result;
24041
24042   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24043   jresult = result;
24044   return jresult;
24045 }
24046
24047
24048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24049   void * jresult ;
24050   Dali::TextureType::Type arg1 ;
24051   Dali::Pixel::Format arg2 ;
24052   unsigned int arg3 ;
24053   unsigned int arg4 ;
24054   Dali::Texture result;
24055
24056   arg1 = (Dali::TextureType::Type)jarg1;
24057   arg2 = (Dali::Pixel::Format)jarg2;
24058   arg3 = (unsigned int)jarg3;
24059   arg4 = (unsigned int)jarg4;
24060   {
24061     try {
24062       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24063     } catch (std::out_of_range& e) {
24064       {
24065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24066       };
24067     } catch (std::exception& e) {
24068       {
24069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24070       };
24071     } catch (Dali::DaliException e) {
24072       {
24073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24074       };
24075     } catch (...) {
24076       {
24077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24078       };
24079     }
24080   }
24081
24082   jresult = new Dali::Texture((const Dali::Texture &)result);
24083   return jresult;
24084 }
24085
24086
24087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24088   void * jresult ;
24089   NativeImageInterface *arg1 = 0 ;
24090   Dali::Texture result;
24091
24092   arg1 = (NativeImageInterface *)jarg1;
24093   if (!arg1) {
24094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24095     return 0;
24096   }
24097   {
24098     try {
24099       result = Dali::Texture::New(*arg1);
24100     } catch (std::out_of_range& e) {
24101       {
24102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24103       };
24104     } catch (std::exception& e) {
24105       {
24106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24107       };
24108     } catch (Dali::DaliException e) {
24109       {
24110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24111       };
24112     } catch (...) {
24113       {
24114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24115       };
24116     }
24117   }
24118
24119   jresult = new Dali::Texture((const Dali::Texture &)result);
24120   return jresult;
24121 }
24122
24123
24124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24125   void * jresult ;
24126   Dali::Texture *result = 0 ;
24127
24128   {
24129     try {
24130       result = (Dali::Texture *)new Dali::Texture();
24131     } catch (std::out_of_range& e) {
24132       {
24133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24134       };
24135     } catch (std::exception& e) {
24136       {
24137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24138       };
24139     } catch (Dali::DaliException e) {
24140       {
24141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24142       };
24143     } catch (...) {
24144       {
24145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24146       };
24147     }
24148   }
24149
24150   jresult = (void *)result;
24151   return jresult;
24152 }
24153
24154
24155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24156   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24157
24158   arg1 = (Dali::Texture *)jarg1;
24159   {
24160     try {
24161       delete arg1;
24162     } catch (std::out_of_range& e) {
24163       {
24164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24165       };
24166     } catch (std::exception& e) {
24167       {
24168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24169       };
24170     } catch (Dali::DaliException e) {
24171       {
24172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24173       };
24174     } catch (...) {
24175       {
24176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24177       };
24178     }
24179   }
24180
24181 }
24182
24183
24184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24185   void * jresult ;
24186   Dali::Texture *arg1 = 0 ;
24187   Dali::Texture *result = 0 ;
24188
24189   arg1 = (Dali::Texture *)jarg1;
24190   if (!arg1) {
24191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24192     return 0;
24193   }
24194   {
24195     try {
24196       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24197     } catch (std::out_of_range& e) {
24198       {
24199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24200       };
24201     } catch (std::exception& e) {
24202       {
24203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24204       };
24205     } catch (Dali::DaliException e) {
24206       {
24207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24208       };
24209     } catch (...) {
24210       {
24211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24212       };
24213     }
24214   }
24215
24216   jresult = (void *)result;
24217   return jresult;
24218 }
24219
24220
24221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24222   void * jresult ;
24223   Dali::BaseHandle arg1 ;
24224   Dali::BaseHandle *argp1 ;
24225   Dali::Texture result;
24226
24227   argp1 = (Dali::BaseHandle *)jarg1;
24228   if (!argp1) {
24229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24230     return 0;
24231   }
24232   arg1 = *argp1;
24233   {
24234     try {
24235       result = Dali::Texture::DownCast(arg1);
24236     } catch (std::out_of_range& e) {
24237       {
24238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24239       };
24240     } catch (std::exception& e) {
24241       {
24242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24243       };
24244     } catch (Dali::DaliException e) {
24245       {
24246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24247       };
24248     } catch (...) {
24249       {
24250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24251       };
24252     }
24253   }
24254
24255   jresult = new Dali::Texture((const Dali::Texture &)result);
24256   return jresult;
24257 }
24258
24259
24260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24261   void * jresult ;
24262   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24263   Dali::Texture *arg2 = 0 ;
24264   Dali::Texture *result = 0 ;
24265
24266   arg1 = (Dali::Texture *)jarg1;
24267   arg2 = (Dali::Texture *)jarg2;
24268   if (!arg2) {
24269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24270     return 0;
24271   }
24272   {
24273     try {
24274       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24275     } catch (std::out_of_range& e) {
24276       {
24277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24278       };
24279     } catch (std::exception& e) {
24280       {
24281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24282       };
24283     } catch (Dali::DaliException e) {
24284       {
24285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24286       };
24287     } catch (...) {
24288       {
24289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24290       };
24291     }
24292   }
24293
24294   jresult = (void *)result;
24295   return jresult;
24296 }
24297
24298
24299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24300   unsigned int jresult ;
24301   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24302   Dali::PixelData arg2 ;
24303   Dali::PixelData *argp2 ;
24304   bool result;
24305
24306   arg1 = (Dali::Texture *)jarg1;
24307   argp2 = (Dali::PixelData *)jarg2;
24308   if (!argp2) {
24309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24310     return 0;
24311   }
24312   arg2 = *argp2;
24313   {
24314     try {
24315       result = (bool)(arg1)->Upload(arg2);
24316     } catch (std::out_of_range& e) {
24317       {
24318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24319       };
24320     } catch (std::exception& e) {
24321       {
24322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24323       };
24324     } catch (Dali::DaliException e) {
24325       {
24326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24327       };
24328     } catch (...) {
24329       {
24330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24331       };
24332     }
24333   }
24334
24335   jresult = result;
24336   return jresult;
24337 }
24338
24339
24340 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) {
24341   unsigned int jresult ;
24342   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24343   Dali::PixelData arg2 ;
24344   unsigned int arg3 ;
24345   unsigned int arg4 ;
24346   unsigned int arg5 ;
24347   unsigned int arg6 ;
24348   unsigned int arg7 ;
24349   unsigned int arg8 ;
24350   Dali::PixelData *argp2 ;
24351   bool result;
24352
24353   arg1 = (Dali::Texture *)jarg1;
24354   argp2 = (Dali::PixelData *)jarg2;
24355   if (!argp2) {
24356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24357     return 0;
24358   }
24359   arg2 = *argp2;
24360   arg3 = (unsigned int)jarg3;
24361   arg4 = (unsigned int)jarg4;
24362   arg5 = (unsigned int)jarg5;
24363   arg6 = (unsigned int)jarg6;
24364   arg7 = (unsigned int)jarg7;
24365   arg8 = (unsigned int)jarg8;
24366   {
24367     try {
24368       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24369     } catch (std::out_of_range& e) {
24370       {
24371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24372       };
24373     } catch (std::exception& e) {
24374       {
24375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24376       };
24377     } catch (Dali::DaliException e) {
24378       {
24379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24380       };
24381     } catch (...) {
24382       {
24383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24384       };
24385     }
24386   }
24387
24388   jresult = result;
24389   return jresult;
24390 }
24391
24392
24393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24394   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24395
24396   arg1 = (Dali::Texture *)jarg1;
24397   {
24398     try {
24399       (arg1)->GenerateMipmaps();
24400     } catch (std::out_of_range& e) {
24401       {
24402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24403       };
24404     } catch (std::exception& e) {
24405       {
24406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24407       };
24408     } catch (Dali::DaliException e) {
24409       {
24410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24411       };
24412     } catch (...) {
24413       {
24414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24415       };
24416     }
24417   }
24418
24419 }
24420
24421
24422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24423   unsigned int jresult ;
24424   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24425   unsigned int result;
24426
24427   arg1 = (Dali::Texture *)jarg1;
24428   {
24429     try {
24430       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24431     } catch (std::out_of_range& e) {
24432       {
24433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24434       };
24435     } catch (std::exception& e) {
24436       {
24437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24438       };
24439     } catch (Dali::DaliException e) {
24440       {
24441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24442       };
24443     } catch (...) {
24444       {
24445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24446       };
24447     }
24448   }
24449
24450   jresult = result;
24451   return jresult;
24452 }
24453
24454
24455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24456   unsigned int jresult ;
24457   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24458   unsigned int result;
24459
24460   arg1 = (Dali::Texture *)jarg1;
24461   {
24462     try {
24463       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24464     } catch (std::out_of_range& e) {
24465       {
24466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24467       };
24468     } catch (std::exception& e) {
24469       {
24470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24471       };
24472     } catch (Dali::DaliException e) {
24473       {
24474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24475       };
24476     } catch (...) {
24477       {
24478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24479       };
24480     }
24481   }
24482
24483   jresult = result;
24484   return jresult;
24485 }
24486
24487
24488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24489   void * jresult ;
24490   Dali::Sampler result;
24491
24492   {
24493     try {
24494       result = Dali::Sampler::New();
24495     } catch (std::out_of_range& e) {
24496       {
24497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24498       };
24499     } catch (std::exception& e) {
24500       {
24501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24502       };
24503     } catch (Dali::DaliException e) {
24504       {
24505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24506       };
24507     } catch (...) {
24508       {
24509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24510       };
24511     }
24512   }
24513
24514   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24515   return jresult;
24516 }
24517
24518
24519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24520   void * jresult ;
24521   Dali::Sampler *result = 0 ;
24522
24523   {
24524     try {
24525       result = (Dali::Sampler *)new Dali::Sampler();
24526     } catch (std::out_of_range& e) {
24527       {
24528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24529       };
24530     } catch (std::exception& e) {
24531       {
24532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24533       };
24534     } catch (Dali::DaliException e) {
24535       {
24536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24537       };
24538     } catch (...) {
24539       {
24540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24541       };
24542     }
24543   }
24544
24545   jresult = (void *)result;
24546   return jresult;
24547 }
24548
24549
24550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24551   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24552
24553   arg1 = (Dali::Sampler *)jarg1;
24554   {
24555     try {
24556       delete arg1;
24557     } catch (std::out_of_range& e) {
24558       {
24559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24560       };
24561     } catch (std::exception& e) {
24562       {
24563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24564       };
24565     } catch (Dali::DaliException e) {
24566       {
24567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24568       };
24569     } catch (...) {
24570       {
24571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24572       };
24573     }
24574   }
24575
24576 }
24577
24578
24579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24580   void * jresult ;
24581   Dali::Sampler *arg1 = 0 ;
24582   Dali::Sampler *result = 0 ;
24583
24584   arg1 = (Dali::Sampler *)jarg1;
24585   if (!arg1) {
24586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24587     return 0;
24588   }
24589   {
24590     try {
24591       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24592     } catch (std::out_of_range& e) {
24593       {
24594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24595       };
24596     } catch (std::exception& e) {
24597       {
24598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24599       };
24600     } catch (Dali::DaliException e) {
24601       {
24602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24603       };
24604     } catch (...) {
24605       {
24606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24607       };
24608     }
24609   }
24610
24611   jresult = (void *)result;
24612   return jresult;
24613 }
24614
24615
24616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24617   void * jresult ;
24618   Dali::BaseHandle arg1 ;
24619   Dali::BaseHandle *argp1 ;
24620   Dali::Sampler result;
24621
24622   argp1 = (Dali::BaseHandle *)jarg1;
24623   if (!argp1) {
24624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24625     return 0;
24626   }
24627   arg1 = *argp1;
24628   {
24629     try {
24630       result = Dali::Sampler::DownCast(arg1);
24631     } catch (std::out_of_range& e) {
24632       {
24633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24634       };
24635     } catch (std::exception& e) {
24636       {
24637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24638       };
24639     } catch (Dali::DaliException e) {
24640       {
24641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24642       };
24643     } catch (...) {
24644       {
24645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24646       };
24647     }
24648   }
24649
24650   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24651   return jresult;
24652 }
24653
24654
24655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24656   void * jresult ;
24657   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24658   Dali::Sampler *arg2 = 0 ;
24659   Dali::Sampler *result = 0 ;
24660
24661   arg1 = (Dali::Sampler *)jarg1;
24662   arg2 = (Dali::Sampler *)jarg2;
24663   if (!arg2) {
24664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24665     return 0;
24666   }
24667   {
24668     try {
24669       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24670     } catch (std::out_of_range& e) {
24671       {
24672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24673       };
24674     } catch (std::exception& e) {
24675       {
24676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24677       };
24678     } catch (Dali::DaliException e) {
24679       {
24680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24681       };
24682     } catch (...) {
24683       {
24684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24685       };
24686     }
24687   }
24688
24689   jresult = (void *)result;
24690   return jresult;
24691 }
24692
24693
24694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24695   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24696   Dali::FilterMode::Type arg2 ;
24697   Dali::FilterMode::Type arg3 ;
24698
24699   arg1 = (Dali::Sampler *)jarg1;
24700   arg2 = (Dali::FilterMode::Type)jarg2;
24701   arg3 = (Dali::FilterMode::Type)jarg3;
24702   {
24703     try {
24704       (arg1)->SetFilterMode(arg2,arg3);
24705     } catch (std::out_of_range& e) {
24706       {
24707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24708       };
24709     } catch (std::exception& e) {
24710       {
24711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24712       };
24713     } catch (Dali::DaliException e) {
24714       {
24715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24716       };
24717     } catch (...) {
24718       {
24719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24720       };
24721     }
24722   }
24723
24724 }
24725
24726
24727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24728   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24729   Dali::WrapMode::Type arg2 ;
24730   Dali::WrapMode::Type arg3 ;
24731
24732   arg1 = (Dali::Sampler *)jarg1;
24733   arg2 = (Dali::WrapMode::Type)jarg2;
24734   arg3 = (Dali::WrapMode::Type)jarg3;
24735   {
24736     try {
24737       (arg1)->SetWrapMode(arg2,arg3);
24738     } catch (std::out_of_range& e) {
24739       {
24740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24741       };
24742     } catch (std::exception& e) {
24743       {
24744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24745       };
24746     } catch (Dali::DaliException e) {
24747       {
24748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24749       };
24750     } catch (...) {
24751       {
24752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24753       };
24754     }
24755   }
24756
24757 }
24758
24759
24760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
24761   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24762   Dali::WrapMode::Type arg2 ;
24763   Dali::WrapMode::Type arg3 ;
24764   Dali::WrapMode::Type arg4 ;
24765
24766   arg1 = (Dali::Sampler *)jarg1;
24767   arg2 = (Dali::WrapMode::Type)jarg2;
24768   arg3 = (Dali::WrapMode::Type)jarg3;
24769   arg4 = (Dali::WrapMode::Type)jarg4;
24770   {
24771     try {
24772       (arg1)->SetWrapMode(arg2,arg3,arg4);
24773     } catch (std::out_of_range& e) {
24774       {
24775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24776       };
24777     } catch (std::exception& e) {
24778       {
24779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24780       };
24781     } catch (Dali::DaliException e) {
24782       {
24783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24784       };
24785     } catch (...) {
24786       {
24787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24788       };
24789     }
24790   }
24791
24792 }
24793
24794
24795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
24796   void * jresult ;
24797   Dali::TextureSet result;
24798
24799   {
24800     try {
24801       result = Dali::TextureSet::New();
24802     } catch (std::out_of_range& e) {
24803       {
24804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24805       };
24806     } catch (std::exception& e) {
24807       {
24808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24809       };
24810     } catch (Dali::DaliException e) {
24811       {
24812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24813       };
24814     } catch (...) {
24815       {
24816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24817       };
24818     }
24819   }
24820
24821   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24822   return jresult;
24823 }
24824
24825
24826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
24827   void * jresult ;
24828   Dali::TextureSet *result = 0 ;
24829
24830   {
24831     try {
24832       result = (Dali::TextureSet *)new Dali::TextureSet();
24833     } catch (std::out_of_range& e) {
24834       {
24835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24836       };
24837     } catch (std::exception& e) {
24838       {
24839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24840       };
24841     } catch (Dali::DaliException e) {
24842       {
24843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24844       };
24845     } catch (...) {
24846       {
24847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24848       };
24849     }
24850   }
24851
24852   jresult = (void *)result;
24853   return jresult;
24854 }
24855
24856
24857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
24858   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24859
24860   arg1 = (Dali::TextureSet *)jarg1;
24861   {
24862     try {
24863       delete arg1;
24864     } catch (std::out_of_range& e) {
24865       {
24866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24867       };
24868     } catch (std::exception& e) {
24869       {
24870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24871       };
24872     } catch (Dali::DaliException e) {
24873       {
24874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24875       };
24876     } catch (...) {
24877       {
24878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24879       };
24880     }
24881   }
24882
24883 }
24884
24885
24886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
24887   void * jresult ;
24888   Dali::TextureSet *arg1 = 0 ;
24889   Dali::TextureSet *result = 0 ;
24890
24891   arg1 = (Dali::TextureSet *)jarg1;
24892   if (!arg1) {
24893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24894     return 0;
24895   }
24896   {
24897     try {
24898       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
24899     } catch (std::out_of_range& e) {
24900       {
24901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24902       };
24903     } catch (std::exception& e) {
24904       {
24905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24906       };
24907     } catch (Dali::DaliException e) {
24908       {
24909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24910       };
24911     } catch (...) {
24912       {
24913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24914       };
24915     }
24916   }
24917
24918   jresult = (void *)result;
24919   return jresult;
24920 }
24921
24922
24923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
24924   void * jresult ;
24925   Dali::BaseHandle arg1 ;
24926   Dali::BaseHandle *argp1 ;
24927   Dali::TextureSet result;
24928
24929   argp1 = (Dali::BaseHandle *)jarg1;
24930   if (!argp1) {
24931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24932     return 0;
24933   }
24934   arg1 = *argp1;
24935   {
24936     try {
24937       result = Dali::TextureSet::DownCast(arg1);
24938     } catch (std::out_of_range& e) {
24939       {
24940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24941       };
24942     } catch (std::exception& e) {
24943       {
24944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24945       };
24946     } catch (Dali::DaliException e) {
24947       {
24948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24949       };
24950     } catch (...) {
24951       {
24952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24953       };
24954     }
24955   }
24956
24957   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24958   return jresult;
24959 }
24960
24961
24962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
24963   void * jresult ;
24964   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24965   Dali::TextureSet *arg2 = 0 ;
24966   Dali::TextureSet *result = 0 ;
24967
24968   arg1 = (Dali::TextureSet *)jarg1;
24969   arg2 = (Dali::TextureSet *)jarg2;
24970   if (!arg2) {
24971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24972     return 0;
24973   }
24974   {
24975     try {
24976       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
24977     } catch (std::out_of_range& e) {
24978       {
24979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24980       };
24981     } catch (std::exception& e) {
24982       {
24983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24984       };
24985     } catch (Dali::DaliException e) {
24986       {
24987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24988       };
24989     } catch (...) {
24990       {
24991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24992       };
24993     }
24994   }
24995
24996   jresult = (void *)result;
24997   return jresult;
24998 }
24999
25000
25001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25002   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25003   size_t arg2 ;
25004   Dali::Texture arg3 ;
25005   Dali::Texture *argp3 ;
25006
25007   arg1 = (Dali::TextureSet *)jarg1;
25008   arg2 = (size_t)jarg2;
25009   argp3 = (Dali::Texture *)jarg3;
25010   if (!argp3) {
25011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25012     return ;
25013   }
25014   arg3 = *argp3;
25015   {
25016     try {
25017       (arg1)->SetTexture(arg2,arg3);
25018     } catch (std::out_of_range& e) {
25019       {
25020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25021       };
25022     } catch (std::exception& e) {
25023       {
25024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25025       };
25026     } catch (Dali::DaliException e) {
25027       {
25028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25029       };
25030     } catch (...) {
25031       {
25032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25033       };
25034     }
25035   }
25036
25037 }
25038
25039
25040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25041   void * jresult ;
25042   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25043   size_t arg2 ;
25044   Dali::Texture result;
25045
25046   arg1 = (Dali::TextureSet *)jarg1;
25047   arg2 = (size_t)jarg2;
25048   {
25049     try {
25050       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25051     } catch (std::out_of_range& e) {
25052       {
25053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25054       };
25055     } catch (std::exception& e) {
25056       {
25057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25058       };
25059     } catch (Dali::DaliException e) {
25060       {
25061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25062       };
25063     } catch (...) {
25064       {
25065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25066       };
25067     }
25068   }
25069
25070   jresult = new Dali::Texture((const Dali::Texture &)result);
25071   return jresult;
25072 }
25073
25074
25075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25076   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25077   size_t arg2 ;
25078   Dali::Sampler arg3 ;
25079   Dali::Sampler *argp3 ;
25080
25081   arg1 = (Dali::TextureSet *)jarg1;
25082   arg2 = (size_t)jarg2;
25083   argp3 = (Dali::Sampler *)jarg3;
25084   if (!argp3) {
25085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25086     return ;
25087   }
25088   arg3 = *argp3;
25089   {
25090     try {
25091       (arg1)->SetSampler(arg2,arg3);
25092     } catch (std::out_of_range& e) {
25093       {
25094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25095       };
25096     } catch (std::exception& e) {
25097       {
25098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25099       };
25100     } catch (Dali::DaliException e) {
25101       {
25102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25103       };
25104     } catch (...) {
25105       {
25106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25107       };
25108     }
25109   }
25110
25111 }
25112
25113
25114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25115   void * jresult ;
25116   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25117   size_t arg2 ;
25118   Dali::Sampler result;
25119
25120   arg1 = (Dali::TextureSet *)jarg1;
25121   arg2 = (size_t)jarg2;
25122   {
25123     try {
25124       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25125     } catch (std::out_of_range& e) {
25126       {
25127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25128       };
25129     } catch (std::exception& e) {
25130       {
25131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25132       };
25133     } catch (Dali::DaliException e) {
25134       {
25135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25136       };
25137     } catch (...) {
25138       {
25139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25140       };
25141     }
25142   }
25143
25144   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25145   return jresult;
25146 }
25147
25148
25149 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25150   unsigned long jresult ;
25151   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25152   size_t result;
25153
25154   arg1 = (Dali::TextureSet *)jarg1;
25155   {
25156     try {
25157       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25158     } catch (std::out_of_range& e) {
25159       {
25160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25161       };
25162     } catch (std::exception& e) {
25163       {
25164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25165       };
25166     } catch (Dali::DaliException e) {
25167       {
25168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25169       };
25170     } catch (...) {
25171       {
25172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25173       };
25174     }
25175   }
25176
25177   jresult = (unsigned long)result;
25178   return jresult;
25179 }
25180
25181
25182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25183   void * jresult ;
25184   Dali::Property::Map *arg1 = 0 ;
25185   Dali::PropertyBuffer result;
25186
25187   arg1 = (Dali::Property::Map *)jarg1;
25188   if (!arg1) {
25189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25190     return 0;
25191   }
25192   {
25193     try {
25194       result = Dali::PropertyBuffer::New(*arg1);
25195     } catch (std::out_of_range& e) {
25196       {
25197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25198       };
25199     } catch (std::exception& e) {
25200       {
25201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25202       };
25203     } catch (Dali::DaliException e) {
25204       {
25205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25206       };
25207     } catch (...) {
25208       {
25209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25210       };
25211     }
25212   }
25213
25214   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25215   return jresult;
25216 }
25217
25218
25219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25220   void * jresult ;
25221   Dali::PropertyBuffer *result = 0 ;
25222
25223   {
25224     try {
25225       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25226     } catch (std::out_of_range& e) {
25227       {
25228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25229       };
25230     } catch (std::exception& e) {
25231       {
25232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25233       };
25234     } catch (Dali::DaliException e) {
25235       {
25236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25237       };
25238     } catch (...) {
25239       {
25240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25241       };
25242     }
25243   }
25244
25245   jresult = (void *)result;
25246   return jresult;
25247 }
25248
25249
25250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25251   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25252
25253   arg1 = (Dali::PropertyBuffer *)jarg1;
25254   {
25255     try {
25256       delete arg1;
25257     } catch (std::out_of_range& e) {
25258       {
25259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25260       };
25261     } catch (std::exception& e) {
25262       {
25263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25264       };
25265     } catch (Dali::DaliException e) {
25266       {
25267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25268       };
25269     } catch (...) {
25270       {
25271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25272       };
25273     }
25274   }
25275
25276 }
25277
25278
25279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25280   void * jresult ;
25281   Dali::PropertyBuffer *arg1 = 0 ;
25282   Dali::PropertyBuffer *result = 0 ;
25283
25284   arg1 = (Dali::PropertyBuffer *)jarg1;
25285   if (!arg1) {
25286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25287     return 0;
25288   }
25289   {
25290     try {
25291       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25292     } catch (std::out_of_range& e) {
25293       {
25294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25295       };
25296     } catch (std::exception& e) {
25297       {
25298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25299       };
25300     } catch (Dali::DaliException e) {
25301       {
25302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25303       };
25304     } catch (...) {
25305       {
25306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25307       };
25308     }
25309   }
25310
25311   jresult = (void *)result;
25312   return jresult;
25313 }
25314
25315
25316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25317   void * jresult ;
25318   Dali::BaseHandle arg1 ;
25319   Dali::BaseHandle *argp1 ;
25320   Dali::PropertyBuffer result;
25321
25322   argp1 = (Dali::BaseHandle *)jarg1;
25323   if (!argp1) {
25324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25325     return 0;
25326   }
25327   arg1 = *argp1;
25328   {
25329     try {
25330       result = Dali::PropertyBuffer::DownCast(arg1);
25331     } catch (std::out_of_range& e) {
25332       {
25333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25334       };
25335     } catch (std::exception& e) {
25336       {
25337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25338       };
25339     } catch (Dali::DaliException e) {
25340       {
25341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25342       };
25343     } catch (...) {
25344       {
25345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25346       };
25347     }
25348   }
25349
25350   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25351   return jresult;
25352 }
25353
25354
25355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25356   void * jresult ;
25357   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25358   Dali::PropertyBuffer *arg2 = 0 ;
25359   Dali::PropertyBuffer *result = 0 ;
25360
25361   arg1 = (Dali::PropertyBuffer *)jarg1;
25362   arg2 = (Dali::PropertyBuffer *)jarg2;
25363   if (!arg2) {
25364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25365     return 0;
25366   }
25367   {
25368     try {
25369       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25370     } catch (std::out_of_range& e) {
25371       {
25372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25373       };
25374     } catch (std::exception& e) {
25375       {
25376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25377       };
25378     } catch (Dali::DaliException e) {
25379       {
25380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25381       };
25382     } catch (...) {
25383       {
25384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25385       };
25386     }
25387   }
25388
25389   jresult = (void *)result;
25390   return jresult;
25391 }
25392
25393
25394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25395   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25396   void *arg2 = (void *) 0 ;
25397   std::size_t arg3 ;
25398
25399   arg1 = (Dali::PropertyBuffer *)jarg1;
25400   arg2 = jarg2;
25401   arg3 = (std::size_t)jarg3;
25402   {
25403     try {
25404       (arg1)->SetData((void const *)arg2,arg3);
25405     } catch (std::out_of_range& e) {
25406       {
25407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25408       };
25409     } catch (std::exception& e) {
25410       {
25411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25412       };
25413     } catch (Dali::DaliException e) {
25414       {
25415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25416       };
25417     } catch (...) {
25418       {
25419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25420       };
25421     }
25422   }
25423
25424 }
25425
25426
25427 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25428   unsigned long jresult ;
25429   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25430   std::size_t result;
25431
25432   arg1 = (Dali::PropertyBuffer *)jarg1;
25433   {
25434     try {
25435       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25436     } catch (std::out_of_range& e) {
25437       {
25438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25439       };
25440     } catch (std::exception& e) {
25441       {
25442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25443       };
25444     } catch (Dali::DaliException e) {
25445       {
25446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25447       };
25448     } catch (...) {
25449       {
25450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25451       };
25452     }
25453   }
25454
25455   jresult = (unsigned long)result;
25456   return jresult;
25457 }
25458
25459
25460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25461   void * jresult ;
25462   Dali::Geometry result;
25463
25464   {
25465     try {
25466       result = Dali::Geometry::New();
25467     } catch (std::out_of_range& e) {
25468       {
25469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25470       };
25471     } catch (std::exception& e) {
25472       {
25473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25474       };
25475     } catch (Dali::DaliException e) {
25476       {
25477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25478       };
25479     } catch (...) {
25480       {
25481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25482       };
25483     }
25484   }
25485
25486   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25487   return jresult;
25488 }
25489
25490
25491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25492   void * jresult ;
25493   Dali::Geometry *result = 0 ;
25494
25495   {
25496     try {
25497       result = (Dali::Geometry *)new Dali::Geometry();
25498     } catch (std::out_of_range& e) {
25499       {
25500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25501       };
25502     } catch (std::exception& e) {
25503       {
25504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25505       };
25506     } catch (Dali::DaliException e) {
25507       {
25508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25509       };
25510     } catch (...) {
25511       {
25512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25513       };
25514     }
25515   }
25516
25517   jresult = (void *)result;
25518   return jresult;
25519 }
25520
25521
25522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25523   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25524
25525   arg1 = (Dali::Geometry *)jarg1;
25526   {
25527     try {
25528       delete arg1;
25529     } catch (std::out_of_range& e) {
25530       {
25531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25532       };
25533     } catch (std::exception& e) {
25534       {
25535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25536       };
25537     } catch (Dali::DaliException e) {
25538       {
25539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25540       };
25541     } catch (...) {
25542       {
25543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25544       };
25545     }
25546   }
25547
25548 }
25549
25550
25551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25552   void * jresult ;
25553   Dali::Geometry *arg1 = 0 ;
25554   Dali::Geometry *result = 0 ;
25555
25556   arg1 = (Dali::Geometry *)jarg1;
25557   if (!arg1) {
25558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25559     return 0;
25560   }
25561   {
25562     try {
25563       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25564     } catch (std::out_of_range& e) {
25565       {
25566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25567       };
25568     } catch (std::exception& e) {
25569       {
25570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25571       };
25572     } catch (Dali::DaliException e) {
25573       {
25574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25575       };
25576     } catch (...) {
25577       {
25578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25579       };
25580     }
25581   }
25582
25583   jresult = (void *)result;
25584   return jresult;
25585 }
25586
25587
25588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25589   void * jresult ;
25590   Dali::BaseHandle arg1 ;
25591   Dali::BaseHandle *argp1 ;
25592   Dali::Geometry result;
25593
25594   argp1 = (Dali::BaseHandle *)jarg1;
25595   if (!argp1) {
25596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25597     return 0;
25598   }
25599   arg1 = *argp1;
25600   {
25601     try {
25602       result = Dali::Geometry::DownCast(arg1);
25603     } catch (std::out_of_range& e) {
25604       {
25605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25606       };
25607     } catch (std::exception& e) {
25608       {
25609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25610       };
25611     } catch (Dali::DaliException e) {
25612       {
25613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25614       };
25615     } catch (...) {
25616       {
25617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25618       };
25619     }
25620   }
25621
25622   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25623   return jresult;
25624 }
25625
25626
25627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25628   void * jresult ;
25629   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25630   Dali::Geometry *arg2 = 0 ;
25631   Dali::Geometry *result = 0 ;
25632
25633   arg1 = (Dali::Geometry *)jarg1;
25634   arg2 = (Dali::Geometry *)jarg2;
25635   if (!arg2) {
25636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25637     return 0;
25638   }
25639   {
25640     try {
25641       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25642     } catch (std::out_of_range& e) {
25643       {
25644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25645       };
25646     } catch (std::exception& e) {
25647       {
25648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25649       };
25650     } catch (Dali::DaliException e) {
25651       {
25652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25653       };
25654     } catch (...) {
25655       {
25656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25657       };
25658     }
25659   }
25660
25661   jresult = (void *)result;
25662   return jresult;
25663 }
25664
25665
25666 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25667   unsigned long jresult ;
25668   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25669   Dali::PropertyBuffer *arg2 = 0 ;
25670   std::size_t result;
25671
25672   arg1 = (Dali::Geometry *)jarg1;
25673   arg2 = (Dali::PropertyBuffer *)jarg2;
25674   if (!arg2) {
25675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25676     return 0;
25677   }
25678   {
25679     try {
25680       result = (arg1)->AddVertexBuffer(*arg2);
25681     } catch (std::out_of_range& e) {
25682       {
25683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25684       };
25685     } catch (std::exception& e) {
25686       {
25687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25688       };
25689     } catch (Dali::DaliException e) {
25690       {
25691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25692       };
25693     } catch (...) {
25694       {
25695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25696       };
25697     }
25698   }
25699
25700   jresult = (unsigned long)result;
25701   return jresult;
25702 }
25703
25704
25705 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25706   unsigned long jresult ;
25707   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25708   std::size_t result;
25709
25710   arg1 = (Dali::Geometry *)jarg1;
25711   {
25712     try {
25713       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25714     } catch (std::out_of_range& e) {
25715       {
25716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25717       };
25718     } catch (std::exception& e) {
25719       {
25720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25721       };
25722     } catch (Dali::DaliException e) {
25723       {
25724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25725       };
25726     } catch (...) {
25727       {
25728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25729       };
25730     }
25731   }
25732
25733   jresult = (unsigned long)result;
25734   return jresult;
25735 }
25736
25737
25738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25739   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25740   std::size_t arg2 ;
25741
25742   arg1 = (Dali::Geometry *)jarg1;
25743   arg2 = (std::size_t)jarg2;
25744   {
25745     try {
25746       (arg1)->RemoveVertexBuffer(arg2);
25747     } catch (std::out_of_range& e) {
25748       {
25749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25750       };
25751     } catch (std::exception& e) {
25752       {
25753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25754       };
25755     } catch (Dali::DaliException e) {
25756       {
25757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25758       };
25759     } catch (...) {
25760       {
25761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25762       };
25763     }
25764   }
25765
25766 }
25767
25768
25769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
25770   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25771   unsigned short *arg2 = (unsigned short *) 0 ;
25772   size_t arg3 ;
25773
25774   arg1 = (Dali::Geometry *)jarg1;
25775   arg2 = jarg2;
25776   arg3 = (size_t)jarg3;
25777   {
25778     try {
25779       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
25780     } catch (std::out_of_range& e) {
25781       {
25782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25783       };
25784     } catch (std::exception& e) {
25785       {
25786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25787       };
25788     } catch (Dali::DaliException e) {
25789       {
25790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25791       };
25792     } catch (...) {
25793       {
25794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25795       };
25796     }
25797   }
25798
25799
25800
25801 }
25802
25803
25804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
25805   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25806   Dali::Geometry::Type arg2 ;
25807
25808   arg1 = (Dali::Geometry *)jarg1;
25809   arg2 = (Dali::Geometry::Type)jarg2;
25810   {
25811     try {
25812       (arg1)->SetType(arg2);
25813     } catch (std::out_of_range& e) {
25814       {
25815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25816       };
25817     } catch (std::exception& e) {
25818       {
25819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25820       };
25821     } catch (Dali::DaliException e) {
25822       {
25823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25824       };
25825     } catch (...) {
25826       {
25827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25828       };
25829     }
25830   }
25831
25832 }
25833
25834
25835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
25836   int jresult ;
25837   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25838   Dali::Geometry::Type result;
25839
25840   arg1 = (Dali::Geometry *)jarg1;
25841   {
25842     try {
25843       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
25844     } catch (std::out_of_range& e) {
25845       {
25846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25847       };
25848     } catch (std::exception& e) {
25849       {
25850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25851       };
25852     } catch (Dali::DaliException e) {
25853       {
25854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25855       };
25856     } catch (...) {
25857       {
25858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25859       };
25860     }
25861   }
25862
25863   jresult = (int)result;
25864   return jresult;
25865 }
25866
25867
25868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
25869   void * jresult ;
25870   Dali::Shader::Hint *result = 0 ;
25871
25872   {
25873     try {
25874       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
25875     } catch (std::out_of_range& e) {
25876       {
25877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25878       };
25879     } catch (std::exception& e) {
25880       {
25881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25882       };
25883     } catch (Dali::DaliException e) {
25884       {
25885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25886       };
25887     } catch (...) {
25888       {
25889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25890       };
25891     }
25892   }
25893
25894   jresult = (void *)result;
25895   return jresult;
25896 }
25897
25898
25899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
25900   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
25901
25902   arg1 = (Dali::Shader::Hint *)jarg1;
25903   {
25904     try {
25905       delete arg1;
25906     } catch (std::out_of_range& e) {
25907       {
25908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25909       };
25910     } catch (std::exception& e) {
25911       {
25912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25913       };
25914     } catch (Dali::DaliException e) {
25915       {
25916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25917       };
25918     } catch (...) {
25919       {
25920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25921       };
25922     }
25923   }
25924
25925 }
25926
25927
25928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
25929   int jresult ;
25930   int result;
25931
25932   result = (int)Dali::Shader::Property::PROGRAM;
25933   jresult = (int)result;
25934   return jresult;
25935 }
25936
25937
25938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
25939   void * jresult ;
25940   Dali::Shader::Property *result = 0 ;
25941
25942   {
25943     try {
25944       result = (Dali::Shader::Property *)new Dali::Shader::Property();
25945     } catch (std::out_of_range& e) {
25946       {
25947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25948       };
25949     } catch (std::exception& e) {
25950       {
25951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25952       };
25953     } catch (Dali::DaliException e) {
25954       {
25955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25956       };
25957     } catch (...) {
25958       {
25959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25960       };
25961     }
25962   }
25963
25964   jresult = (void *)result;
25965   return jresult;
25966 }
25967
25968
25969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
25970   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
25971
25972   arg1 = (Dali::Shader::Property *)jarg1;
25973   {
25974     try {
25975       delete arg1;
25976     } catch (std::out_of_range& e) {
25977       {
25978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25979       };
25980     } catch (std::exception& e) {
25981       {
25982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25983       };
25984     } catch (Dali::DaliException e) {
25985       {
25986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25987       };
25988     } catch (...) {
25989       {
25990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25991       };
25992     }
25993   }
25994
25995 }
25996
25997
25998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
25999   void * jresult ;
26000   std::string *arg1 = 0 ;
26001   std::string *arg2 = 0 ;
26002   Dali::Shader::Hint::Value arg3 ;
26003   Dali::Shader result;
26004
26005   if (!jarg1) {
26006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26007     return 0;
26008   }
26009   std::string arg1_str(jarg1);
26010   arg1 = &arg1_str;
26011   if (!jarg2) {
26012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26013     return 0;
26014   }
26015   std::string arg2_str(jarg2);
26016   arg2 = &arg2_str;
26017   arg3 = (Dali::Shader::Hint::Value)jarg3;
26018   {
26019     try {
26020       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26021     } catch (std::out_of_range& e) {
26022       {
26023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26024       };
26025     } catch (std::exception& e) {
26026       {
26027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26028       };
26029     } catch (Dali::DaliException e) {
26030       {
26031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26032       };
26033     } catch (...) {
26034       {
26035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26036       };
26037     }
26038   }
26039
26040   jresult = new Dali::Shader((const Dali::Shader &)result);
26041
26042   //argout typemap for const std::string&
26043
26044
26045   //argout typemap for const std::string&
26046
26047   return jresult;
26048 }
26049
26050
26051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26052   void * jresult ;
26053   std::string *arg1 = 0 ;
26054   std::string *arg2 = 0 ;
26055   Dali::Shader result;
26056
26057   if (!jarg1) {
26058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26059     return 0;
26060   }
26061   std::string arg1_str(jarg1);
26062   arg1 = &arg1_str;
26063   if (!jarg2) {
26064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26065     return 0;
26066   }
26067   std::string arg2_str(jarg2);
26068   arg2 = &arg2_str;
26069   {
26070     try {
26071       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26072     } catch (std::out_of_range& e) {
26073       {
26074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26075       };
26076     } catch (std::exception& e) {
26077       {
26078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26079       };
26080     } catch (Dali::DaliException e) {
26081       {
26082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26083       };
26084     } catch (...) {
26085       {
26086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26087       };
26088     }
26089   }
26090
26091   jresult = new Dali::Shader((const Dali::Shader &)result);
26092
26093   //argout typemap for const std::string&
26094
26095
26096   //argout typemap for const std::string&
26097
26098   return jresult;
26099 }
26100
26101
26102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26103   void * jresult ;
26104   Dali::Shader *result = 0 ;
26105
26106   {
26107     try {
26108       result = (Dali::Shader *)new Dali::Shader();
26109     } catch (std::out_of_range& e) {
26110       {
26111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26112       };
26113     } catch (std::exception& e) {
26114       {
26115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26116       };
26117     } catch (Dali::DaliException e) {
26118       {
26119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26120       };
26121     } catch (...) {
26122       {
26123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26124       };
26125     }
26126   }
26127
26128   jresult = (void *)result;
26129   return jresult;
26130 }
26131
26132
26133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26134   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26135
26136   arg1 = (Dali::Shader *)jarg1;
26137   {
26138     try {
26139       delete arg1;
26140     } catch (std::out_of_range& e) {
26141       {
26142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26143       };
26144     } catch (std::exception& e) {
26145       {
26146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26147       };
26148     } catch (Dali::DaliException e) {
26149       {
26150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26151       };
26152     } catch (...) {
26153       {
26154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26155       };
26156     }
26157   }
26158
26159 }
26160
26161
26162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26163   void * jresult ;
26164   Dali::Shader *arg1 = 0 ;
26165   Dali::Shader *result = 0 ;
26166
26167   arg1 = (Dali::Shader *)jarg1;
26168   if (!arg1) {
26169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26170     return 0;
26171   }
26172   {
26173     try {
26174       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26175     } catch (std::out_of_range& e) {
26176       {
26177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26178       };
26179     } catch (std::exception& e) {
26180       {
26181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26182       };
26183     } catch (Dali::DaliException e) {
26184       {
26185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26186       };
26187     } catch (...) {
26188       {
26189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26190       };
26191     }
26192   }
26193
26194   jresult = (void *)result;
26195   return jresult;
26196 }
26197
26198
26199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26200   void * jresult ;
26201   Dali::BaseHandle arg1 ;
26202   Dali::BaseHandle *argp1 ;
26203   Dali::Shader result;
26204
26205   argp1 = (Dali::BaseHandle *)jarg1;
26206   if (!argp1) {
26207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26208     return 0;
26209   }
26210   arg1 = *argp1;
26211   {
26212     try {
26213       result = Dali::Shader::DownCast(arg1);
26214     } catch (std::out_of_range& e) {
26215       {
26216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26217       };
26218     } catch (std::exception& e) {
26219       {
26220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26221       };
26222     } catch (Dali::DaliException e) {
26223       {
26224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26225       };
26226     } catch (...) {
26227       {
26228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26229       };
26230     }
26231   }
26232
26233   jresult = new Dali::Shader((const Dali::Shader &)result);
26234   return jresult;
26235 }
26236
26237
26238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26239   void * jresult ;
26240   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26241   Dali::Shader *arg2 = 0 ;
26242   Dali::Shader *result = 0 ;
26243
26244   arg1 = (Dali::Shader *)jarg1;
26245   arg2 = (Dali::Shader *)jarg2;
26246   if (!arg2) {
26247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26248     return 0;
26249   }
26250   {
26251     try {
26252       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26253     } catch (std::out_of_range& e) {
26254       {
26255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26256       };
26257     } catch (std::exception& e) {
26258       {
26259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26260       };
26261     } catch (Dali::DaliException e) {
26262       {
26263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26264       };
26265     } catch (...) {
26266       {
26267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26268       };
26269     }
26270   }
26271
26272   jresult = (void *)result;
26273   return jresult;
26274 }
26275
26276
26277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26278   int jresult ;
26279   int result;
26280
26281   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26282   jresult = (int)result;
26283   return jresult;
26284 }
26285
26286
26287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26288   int jresult ;
26289   int result;
26290
26291   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26292   jresult = (int)result;
26293   return jresult;
26294 }
26295
26296
26297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26298   int jresult ;
26299   int result;
26300
26301   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26302   jresult = (int)result;
26303   return jresult;
26304 }
26305
26306
26307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26308   int jresult ;
26309   int result;
26310
26311   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26312   jresult = (int)result;
26313   return jresult;
26314 }
26315
26316
26317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26318   int jresult ;
26319   int result;
26320
26321   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26322   jresult = (int)result;
26323   return jresult;
26324 }
26325
26326
26327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26328   int jresult ;
26329   int result;
26330
26331   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26332   jresult = (int)result;
26333   return jresult;
26334 }
26335
26336
26337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26338   int jresult ;
26339   int result;
26340
26341   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26342   jresult = (int)result;
26343   return jresult;
26344 }
26345
26346
26347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26348   int jresult ;
26349   int result;
26350
26351   result = (int)Dali::Renderer::Property::BLEND_MODE;
26352   jresult = (int)result;
26353   return jresult;
26354 }
26355
26356
26357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26358   int jresult ;
26359   int result;
26360
26361   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26362   jresult = (int)result;
26363   return jresult;
26364 }
26365
26366
26367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26368   int jresult ;
26369   int result;
26370
26371   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26372   jresult = (int)result;
26373   return jresult;
26374 }
26375
26376
26377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26378   int jresult ;
26379   int result;
26380
26381   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26382   jresult = (int)result;
26383   return jresult;
26384 }
26385
26386
26387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26388   int jresult ;
26389   int result;
26390
26391   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26392   jresult = (int)result;
26393   return jresult;
26394 }
26395
26396
26397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26398   int jresult ;
26399   int result;
26400
26401   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26402   jresult = (int)result;
26403   return jresult;
26404 }
26405
26406
26407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26408   int jresult ;
26409   int result;
26410
26411   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26412   jresult = (int)result;
26413   return jresult;
26414 }
26415
26416
26417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26418   int jresult ;
26419   int result;
26420
26421   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26422   jresult = (int)result;
26423   return jresult;
26424 }
26425
26426
26427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26428   int jresult ;
26429   int result;
26430
26431   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26432   jresult = (int)result;
26433   return jresult;
26434 }
26435
26436
26437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26438   int jresult ;
26439   int result;
26440
26441   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26442   jresult = (int)result;
26443   return jresult;
26444 }
26445
26446
26447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26448   int jresult ;
26449   int result;
26450
26451   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26452   jresult = (int)result;
26453   return jresult;
26454 }
26455
26456
26457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26458   int jresult ;
26459   int result;
26460
26461   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26462   jresult = (int)result;
26463   return jresult;
26464 }
26465
26466
26467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26468   int jresult ;
26469   int result;
26470
26471   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26472   jresult = (int)result;
26473   return jresult;
26474 }
26475
26476
26477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26478   int jresult ;
26479   int result;
26480
26481   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26482   jresult = (int)result;
26483   return jresult;
26484 }
26485
26486
26487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26488   int jresult ;
26489   int result;
26490
26491   result = (int)Dali::Renderer::Property::RENDER_MODE;
26492   jresult = (int)result;
26493   return jresult;
26494 }
26495
26496
26497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26498   int jresult ;
26499   int result;
26500
26501   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26502   jresult = (int)result;
26503   return jresult;
26504 }
26505
26506
26507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26508   int jresult ;
26509   int result;
26510
26511   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26512   jresult = (int)result;
26513   return jresult;
26514 }
26515
26516
26517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26518   int jresult ;
26519   int result;
26520
26521   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26522   jresult = (int)result;
26523   return jresult;
26524 }
26525
26526
26527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26528   int jresult ;
26529   int result;
26530
26531   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26532   jresult = (int)result;
26533   return jresult;
26534 }
26535
26536
26537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26538   int jresult ;
26539   int result;
26540
26541   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26542   jresult = (int)result;
26543   return jresult;
26544 }
26545
26546
26547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26548   int jresult ;
26549   int result;
26550
26551   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26552   jresult = (int)result;
26553   return jresult;
26554 }
26555
26556
26557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26558   int jresult ;
26559   int result;
26560
26561   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26562   jresult = (int)result;
26563   return jresult;
26564 }
26565
26566
26567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26568   void * jresult ;
26569   Dali::Renderer::Property *result = 0 ;
26570
26571   {
26572     try {
26573       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26574     } catch (std::out_of_range& e) {
26575       {
26576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26577       };
26578     } catch (std::exception& e) {
26579       {
26580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26581       };
26582     } catch (Dali::DaliException e) {
26583       {
26584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26585       };
26586     } catch (...) {
26587       {
26588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26589       };
26590     }
26591   }
26592
26593   jresult = (void *)result;
26594   return jresult;
26595 }
26596
26597
26598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26599   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26600
26601   arg1 = (Dali::Renderer::Property *)jarg1;
26602   {
26603     try {
26604       delete arg1;
26605     } catch (std::out_of_range& e) {
26606       {
26607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26608       };
26609     } catch (std::exception& e) {
26610       {
26611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26612       };
26613     } catch (Dali::DaliException e) {
26614       {
26615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26616       };
26617     } catch (...) {
26618       {
26619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26620       };
26621     }
26622   }
26623
26624 }
26625
26626
26627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26628   void * jresult ;
26629   Dali::Geometry *arg1 = 0 ;
26630   Dali::Shader *arg2 = 0 ;
26631   Dali::Renderer result;
26632
26633   arg1 = (Dali::Geometry *)jarg1;
26634   if (!arg1) {
26635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26636     return 0;
26637   }
26638   arg2 = (Dali::Shader *)jarg2;
26639   if (!arg2) {
26640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26641     return 0;
26642   }
26643   {
26644     try {
26645       result = Dali::Renderer::New(*arg1,*arg2);
26646     } catch (std::out_of_range& e) {
26647       {
26648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26649       };
26650     } catch (std::exception& e) {
26651       {
26652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26653       };
26654     } catch (Dali::DaliException e) {
26655       {
26656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26657       };
26658     } catch (...) {
26659       {
26660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26661       };
26662     }
26663   }
26664
26665   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26666   return jresult;
26667 }
26668
26669
26670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26671   void * jresult ;
26672   Dali::Renderer *result = 0 ;
26673
26674   {
26675     try {
26676       result = (Dali::Renderer *)new Dali::Renderer();
26677     } catch (std::out_of_range& e) {
26678       {
26679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26680       };
26681     } catch (std::exception& e) {
26682       {
26683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26684       };
26685     } catch (Dali::DaliException e) {
26686       {
26687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26688       };
26689     } catch (...) {
26690       {
26691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26692       };
26693     }
26694   }
26695
26696   jresult = (void *)result;
26697   return jresult;
26698 }
26699
26700
26701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26702   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26703
26704   arg1 = (Dali::Renderer *)jarg1;
26705   {
26706     try {
26707       delete arg1;
26708     } catch (std::out_of_range& e) {
26709       {
26710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26711       };
26712     } catch (std::exception& e) {
26713       {
26714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26715       };
26716     } catch (Dali::DaliException e) {
26717       {
26718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26719       };
26720     } catch (...) {
26721       {
26722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26723       };
26724     }
26725   }
26726
26727 }
26728
26729
26730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26731   void * jresult ;
26732   Dali::Renderer *arg1 = 0 ;
26733   Dali::Renderer *result = 0 ;
26734
26735   arg1 = (Dali::Renderer *)jarg1;
26736   if (!arg1) {
26737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26738     return 0;
26739   }
26740   {
26741     try {
26742       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26743     } catch (std::out_of_range& e) {
26744       {
26745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26746       };
26747     } catch (std::exception& e) {
26748       {
26749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26750       };
26751     } catch (Dali::DaliException e) {
26752       {
26753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26754       };
26755     } catch (...) {
26756       {
26757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26758       };
26759     }
26760   }
26761
26762   jresult = (void *)result;
26763   return jresult;
26764 }
26765
26766
26767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26768   void * jresult ;
26769   Dali::BaseHandle arg1 ;
26770   Dali::BaseHandle *argp1 ;
26771   Dali::Renderer result;
26772
26773   argp1 = (Dali::BaseHandle *)jarg1;
26774   if (!argp1) {
26775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26776     return 0;
26777   }
26778   arg1 = *argp1;
26779   {
26780     try {
26781       result = Dali::Renderer::DownCast(arg1);
26782     } catch (std::out_of_range& e) {
26783       {
26784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26785       };
26786     } catch (std::exception& e) {
26787       {
26788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26789       };
26790     } catch (Dali::DaliException e) {
26791       {
26792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26793       };
26794     } catch (...) {
26795       {
26796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26797       };
26798     }
26799   }
26800
26801   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26802   return jresult;
26803 }
26804
26805
26806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
26807   void * jresult ;
26808   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26809   Dali::Renderer *arg2 = 0 ;
26810   Dali::Renderer *result = 0 ;
26811
26812   arg1 = (Dali::Renderer *)jarg1;
26813   arg2 = (Dali::Renderer *)jarg2;
26814   if (!arg2) {
26815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26816     return 0;
26817   }
26818   {
26819     try {
26820       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
26821     } catch (std::out_of_range& e) {
26822       {
26823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26824       };
26825     } catch (std::exception& e) {
26826       {
26827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26828       };
26829     } catch (Dali::DaliException e) {
26830       {
26831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26832       };
26833     } catch (...) {
26834       {
26835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26836       };
26837     }
26838   }
26839
26840   jresult = (void *)result;
26841   return jresult;
26842 }
26843
26844
26845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
26846   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26847   Dali::Geometry *arg2 = 0 ;
26848
26849   arg1 = (Dali::Renderer *)jarg1;
26850   arg2 = (Dali::Geometry *)jarg2;
26851   if (!arg2) {
26852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26853     return ;
26854   }
26855   {
26856     try {
26857       (arg1)->SetGeometry(*arg2);
26858     } catch (std::out_of_range& e) {
26859       {
26860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26861       };
26862     } catch (std::exception& e) {
26863       {
26864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26865       };
26866     } catch (Dali::DaliException e) {
26867       {
26868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26869       };
26870     } catch (...) {
26871       {
26872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26873       };
26874     }
26875   }
26876
26877 }
26878
26879
26880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
26881   void * jresult ;
26882   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26883   Dali::Geometry result;
26884
26885   arg1 = (Dali::Renderer *)jarg1;
26886   {
26887     try {
26888       result = ((Dali::Renderer const *)arg1)->GetGeometry();
26889     } catch (std::out_of_range& e) {
26890       {
26891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26892       };
26893     } catch (std::exception& e) {
26894       {
26895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26896       };
26897     } catch (Dali::DaliException e) {
26898       {
26899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26900       };
26901     } catch (...) {
26902       {
26903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26904       };
26905     }
26906   }
26907
26908   jresult = new Dali::Geometry((const Dali::Geometry &)result);
26909   return jresult;
26910 }
26911
26912
26913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
26914   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26915   int arg2 ;
26916   int arg3 ;
26917
26918   arg1 = (Dali::Renderer *)jarg1;
26919   arg2 = (int)jarg2;
26920   arg3 = (int)jarg3;
26921   {
26922     try {
26923       (arg1)->SetIndexRange(arg2,arg3);
26924     } catch (std::out_of_range& e) {
26925       {
26926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26927       };
26928     } catch (std::exception& e) {
26929       {
26930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26931       };
26932     } catch (Dali::DaliException e) {
26933       {
26934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26935       };
26936     } catch (...) {
26937       {
26938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26939       };
26940     }
26941   }
26942
26943 }
26944
26945
26946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
26947   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26948   Dali::TextureSet *arg2 = 0 ;
26949
26950   arg1 = (Dali::Renderer *)jarg1;
26951   arg2 = (Dali::TextureSet *)jarg2;
26952   if (!arg2) {
26953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
26954     return ;
26955   }
26956   {
26957     try {
26958       (arg1)->SetTextures(*arg2);
26959     } catch (std::out_of_range& e) {
26960       {
26961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26962       };
26963     } catch (std::exception& e) {
26964       {
26965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26966       };
26967     } catch (Dali::DaliException e) {
26968       {
26969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26970       };
26971     } catch (...) {
26972       {
26973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26974       };
26975     }
26976   }
26977
26978 }
26979
26980
26981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
26982   void * jresult ;
26983   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26984   Dali::TextureSet result;
26985
26986   arg1 = (Dali::Renderer *)jarg1;
26987   {
26988     try {
26989       result = ((Dali::Renderer const *)arg1)->GetTextures();
26990     } catch (std::out_of_range& e) {
26991       {
26992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26993       };
26994     } catch (std::exception& e) {
26995       {
26996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26997       };
26998     } catch (Dali::DaliException e) {
26999       {
27000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27001       };
27002     } catch (...) {
27003       {
27004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27005       };
27006     }
27007   }
27008
27009   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27010   return jresult;
27011 }
27012
27013
27014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27015   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27016   Dali::Shader *arg2 = 0 ;
27017
27018   arg1 = (Dali::Renderer *)jarg1;
27019   arg2 = (Dali::Shader *)jarg2;
27020   if (!arg2) {
27021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27022     return ;
27023   }
27024   {
27025     try {
27026       (arg1)->SetShader(*arg2);
27027     } catch (std::out_of_range& e) {
27028       {
27029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27030       };
27031     } catch (std::exception& e) {
27032       {
27033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27034       };
27035     } catch (Dali::DaliException e) {
27036       {
27037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27038       };
27039     } catch (...) {
27040       {
27041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27042       };
27043     }
27044   }
27045
27046 }
27047
27048
27049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27050   void * jresult ;
27051   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27052   Dali::Shader result;
27053
27054   arg1 = (Dali::Renderer *)jarg1;
27055   {
27056     try {
27057       result = ((Dali::Renderer const *)arg1)->GetShader();
27058     } catch (std::out_of_range& e) {
27059       {
27060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27061       };
27062     } catch (std::exception& e) {
27063       {
27064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27065       };
27066     } catch (Dali::DaliException e) {
27067       {
27068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27069       };
27070     } catch (...) {
27071       {
27072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27073       };
27074     }
27075   }
27076
27077   jresult = new Dali::Shader((const Dali::Shader &)result);
27078   return jresult;
27079 }
27080
27081
27082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27083   void * jresult ;
27084   Dali::FrameBuffer::Attachment *result = 0 ;
27085
27086   {
27087     try {
27088       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27089     } catch (std::out_of_range& e) {
27090       {
27091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27092       };
27093     } catch (std::exception& e) {
27094       {
27095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27096       };
27097     } catch (Dali::DaliException e) {
27098       {
27099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27100       };
27101     } catch (...) {
27102       {
27103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27104       };
27105     }
27106   }
27107
27108   jresult = (void *)result;
27109   return jresult;
27110 }
27111
27112
27113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27114   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27115
27116   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27117   {
27118     try {
27119       delete arg1;
27120     } catch (std::out_of_range& e) {
27121       {
27122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27123       };
27124     } catch (std::exception& e) {
27125       {
27126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27127       };
27128     } catch (Dali::DaliException e) {
27129       {
27130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27131       };
27132     } catch (...) {
27133       {
27134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27135       };
27136     }
27137   }
27138
27139 }
27140
27141
27142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27143   void * jresult ;
27144   unsigned int arg1 ;
27145   unsigned int arg2 ;
27146   unsigned int arg3 ;
27147   Dali::FrameBuffer result;
27148
27149   arg1 = (unsigned int)jarg1;
27150   arg2 = (unsigned int)jarg2;
27151   arg3 = (unsigned int)jarg3;
27152   {
27153     try {
27154       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
27155     } catch (std::out_of_range& e) {
27156       {
27157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27158       };
27159     } catch (std::exception& e) {
27160       {
27161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27162       };
27163     } catch (Dali::DaliException e) {
27164       {
27165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27166       };
27167     } catch (...) {
27168       {
27169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27170       };
27171     }
27172   }
27173
27174   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27175   return jresult;
27176 }
27177
27178
27179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27180   void * jresult ;
27181   Dali::FrameBuffer *result = 0 ;
27182
27183   {
27184     try {
27185       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27186     } catch (std::out_of_range& e) {
27187       {
27188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27189       };
27190     } catch (std::exception& e) {
27191       {
27192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27193       };
27194     } catch (Dali::DaliException e) {
27195       {
27196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27197       };
27198     } catch (...) {
27199       {
27200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27201       };
27202     }
27203   }
27204
27205   jresult = (void *)result;
27206   return jresult;
27207 }
27208
27209
27210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27211   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27212
27213   arg1 = (Dali::FrameBuffer *)jarg1;
27214   {
27215     try {
27216       delete arg1;
27217     } catch (std::out_of_range& e) {
27218       {
27219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27220       };
27221     } catch (std::exception& e) {
27222       {
27223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27224       };
27225     } catch (Dali::DaliException e) {
27226       {
27227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27228       };
27229     } catch (...) {
27230       {
27231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27232       };
27233     }
27234   }
27235
27236 }
27237
27238
27239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27240   void * jresult ;
27241   Dali::FrameBuffer *arg1 = 0 ;
27242   Dali::FrameBuffer *result = 0 ;
27243
27244   arg1 = (Dali::FrameBuffer *)jarg1;
27245   if (!arg1) {
27246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27247     return 0;
27248   }
27249   {
27250     try {
27251       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27252     } catch (std::out_of_range& e) {
27253       {
27254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27255       };
27256     } catch (std::exception& e) {
27257       {
27258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27259       };
27260     } catch (Dali::DaliException e) {
27261       {
27262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27263       };
27264     } catch (...) {
27265       {
27266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27267       };
27268     }
27269   }
27270
27271   jresult = (void *)result;
27272   return jresult;
27273 }
27274
27275
27276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27277   void * jresult ;
27278   Dali::BaseHandle arg1 ;
27279   Dali::BaseHandle *argp1 ;
27280   Dali::FrameBuffer result;
27281
27282   argp1 = (Dali::BaseHandle *)jarg1;
27283   if (!argp1) {
27284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27285     return 0;
27286   }
27287   arg1 = *argp1;
27288   {
27289     try {
27290       result = Dali::FrameBuffer::DownCast(arg1);
27291     } catch (std::out_of_range& e) {
27292       {
27293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27294       };
27295     } catch (std::exception& e) {
27296       {
27297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27298       };
27299     } catch (Dali::DaliException e) {
27300       {
27301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27302       };
27303     } catch (...) {
27304       {
27305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27306       };
27307     }
27308   }
27309
27310   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27311   return jresult;
27312 }
27313
27314
27315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27316   void * jresult ;
27317   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27318   Dali::FrameBuffer *arg2 = 0 ;
27319   Dali::FrameBuffer *result = 0 ;
27320
27321   arg1 = (Dali::FrameBuffer *)jarg1;
27322   arg2 = (Dali::FrameBuffer *)jarg2;
27323   if (!arg2) {
27324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27325     return 0;
27326   }
27327   {
27328     try {
27329       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27330     } catch (std::out_of_range& e) {
27331       {
27332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27333       };
27334     } catch (std::exception& e) {
27335       {
27336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27337       };
27338     } catch (Dali::DaliException e) {
27339       {
27340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27341       };
27342     } catch (...) {
27343       {
27344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27345       };
27346     }
27347   }
27348
27349   jresult = (void *)result;
27350   return jresult;
27351 }
27352
27353
27354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27355   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27356   Dali::Texture *arg2 = 0 ;
27357
27358   arg1 = (Dali::FrameBuffer *)jarg1;
27359   arg2 = (Dali::Texture *)jarg2;
27360   if (!arg2) {
27361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27362     return ;
27363   }
27364   {
27365     try {
27366       (arg1)->AttachColorTexture(*arg2);
27367     } catch (std::out_of_range& e) {
27368       {
27369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27370       };
27371     } catch (std::exception& e) {
27372       {
27373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27374       };
27375     } catch (Dali::DaliException e) {
27376       {
27377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27378       };
27379     } catch (...) {
27380       {
27381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27382       };
27383     }
27384   }
27385
27386 }
27387
27388
27389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27390   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27391   Dali::Texture *arg2 = 0 ;
27392   unsigned int arg3 ;
27393   unsigned int arg4 ;
27394
27395   arg1 = (Dali::FrameBuffer *)jarg1;
27396   arg2 = (Dali::Texture *)jarg2;
27397   if (!arg2) {
27398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27399     return ;
27400   }
27401   arg3 = (unsigned int)jarg3;
27402   arg4 = (unsigned int)jarg4;
27403   {
27404     try {
27405       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27406     } catch (std::out_of_range& e) {
27407       {
27408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27409       };
27410     } catch (std::exception& e) {
27411       {
27412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27413       };
27414     } catch (Dali::DaliException e) {
27415       {
27416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27417       };
27418     } catch (...) {
27419       {
27420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27421       };
27422     }
27423   }
27424
27425 }
27426
27427
27428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27429   void * jresult ;
27430   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27431   Dali::Texture result;
27432
27433   arg1 = (Dali::FrameBuffer *)jarg1;
27434   {
27435     try {
27436       result = (arg1)->GetColorTexture();
27437     } catch (std::out_of_range& e) {
27438       {
27439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27440       };
27441     } catch (std::exception& e) {
27442       {
27443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27444       };
27445     } catch (Dali::DaliException e) {
27446       {
27447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27448       };
27449     } catch (...) {
27450       {
27451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27452       };
27453     }
27454   }
27455
27456   jresult = new Dali::Texture((const Dali::Texture &)result);
27457   return jresult;
27458 }
27459
27460
27461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27462   void * jresult ;
27463   Dali::RenderTaskList *result = 0 ;
27464
27465   {
27466     try {
27467       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27468     } catch (std::out_of_range& e) {
27469       {
27470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27471       };
27472     } catch (std::exception& e) {
27473       {
27474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27475       };
27476     } catch (Dali::DaliException e) {
27477       {
27478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27479       };
27480     } catch (...) {
27481       {
27482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27483       };
27484     }
27485   }
27486
27487   jresult = (void *)result;
27488   return jresult;
27489 }
27490
27491
27492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27493   void * jresult ;
27494   Dali::BaseHandle arg1 ;
27495   Dali::BaseHandle *argp1 ;
27496   Dali::RenderTaskList result;
27497
27498   argp1 = (Dali::BaseHandle *)jarg1;
27499   if (!argp1) {
27500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27501     return 0;
27502   }
27503   arg1 = *argp1;
27504   {
27505     try {
27506       result = Dali::RenderTaskList::DownCast(arg1);
27507     } catch (std::out_of_range& e) {
27508       {
27509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27510       };
27511     } catch (std::exception& e) {
27512       {
27513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27514       };
27515     } catch (Dali::DaliException e) {
27516       {
27517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27518       };
27519     } catch (...) {
27520       {
27521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27522       };
27523     }
27524   }
27525
27526   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27527   return jresult;
27528 }
27529
27530
27531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27532   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27533
27534   arg1 = (Dali::RenderTaskList *)jarg1;
27535   {
27536     try {
27537       delete arg1;
27538     } catch (std::out_of_range& e) {
27539       {
27540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27541       };
27542     } catch (std::exception& e) {
27543       {
27544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27545       };
27546     } catch (Dali::DaliException e) {
27547       {
27548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27549       };
27550     } catch (...) {
27551       {
27552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27553       };
27554     }
27555   }
27556
27557 }
27558
27559
27560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27561   void * jresult ;
27562   Dali::RenderTaskList *arg1 = 0 ;
27563   Dali::RenderTaskList *result = 0 ;
27564
27565   arg1 = (Dali::RenderTaskList *)jarg1;
27566   if (!arg1) {
27567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27568     return 0;
27569   }
27570   {
27571     try {
27572       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27573     } catch (std::out_of_range& e) {
27574       {
27575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27576       };
27577     } catch (std::exception& e) {
27578       {
27579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27580       };
27581     } catch (Dali::DaliException e) {
27582       {
27583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27584       };
27585     } catch (...) {
27586       {
27587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27588       };
27589     }
27590   }
27591
27592   jresult = (void *)result;
27593   return jresult;
27594 }
27595
27596
27597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27598   void * jresult ;
27599   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27600   Dali::RenderTaskList *arg2 = 0 ;
27601   Dali::RenderTaskList *result = 0 ;
27602
27603   arg1 = (Dali::RenderTaskList *)jarg1;
27604   arg2 = (Dali::RenderTaskList *)jarg2;
27605   if (!arg2) {
27606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27607     return 0;
27608   }
27609   {
27610     try {
27611       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27612     } catch (std::out_of_range& e) {
27613       {
27614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27615       };
27616     } catch (std::exception& e) {
27617       {
27618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27619       };
27620     } catch (Dali::DaliException e) {
27621       {
27622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27623       };
27624     } catch (...) {
27625       {
27626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27627       };
27628     }
27629   }
27630
27631   jresult = (void *)result;
27632   return jresult;
27633 }
27634
27635
27636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27637   void * jresult ;
27638   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27639   Dali::RenderTask result;
27640
27641   arg1 = (Dali::RenderTaskList *)jarg1;
27642   {
27643     try {
27644       result = (arg1)->CreateTask();
27645     } catch (std::out_of_range& e) {
27646       {
27647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27648       };
27649     } catch (std::exception& e) {
27650       {
27651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27652       };
27653     } catch (Dali::DaliException e) {
27654       {
27655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27656       };
27657     } catch (...) {
27658       {
27659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27660       };
27661     }
27662   }
27663
27664   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27665   return jresult;
27666 }
27667
27668
27669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27670   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27671   Dali::RenderTask arg2 ;
27672   Dali::RenderTask *argp2 ;
27673
27674   arg1 = (Dali::RenderTaskList *)jarg1;
27675   argp2 = (Dali::RenderTask *)jarg2;
27676   if (!argp2) {
27677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27678     return ;
27679   }
27680   arg2 = *argp2;
27681   {
27682     try {
27683       (arg1)->RemoveTask(arg2);
27684     } catch (std::out_of_range& e) {
27685       {
27686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27687       };
27688     } catch (std::exception& e) {
27689       {
27690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27691       };
27692     } catch (Dali::DaliException e) {
27693       {
27694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27695       };
27696     } catch (...) {
27697       {
27698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27699       };
27700     }
27701   }
27702
27703 }
27704
27705
27706 //// ===============================================end part 1 =================
27707
27708 //// ========================= part 2 ===============================
27709
27710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27711   unsigned int jresult ;
27712   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27713   unsigned int result;
27714
27715   arg1 = (Dali::RenderTaskList *)jarg1;
27716   {
27717     try {
27718       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27719     } catch (std::out_of_range& e) {
27720       {
27721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27722       };
27723     } catch (std::exception& e) {
27724       {
27725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27726       };
27727     } catch (Dali::DaliException e) {
27728       {
27729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27730       };
27731     } catch (...) {
27732       {
27733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27734       };
27735     }
27736   }
27737
27738   jresult = result;
27739   return jresult;
27740 }
27741
27742
27743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27744   void * jresult ;
27745   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27746   unsigned int arg2 ;
27747   Dali::RenderTask result;
27748
27749   arg1 = (Dali::RenderTaskList *)jarg1;
27750   arg2 = (unsigned int)jarg2;
27751   {
27752     try {
27753       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27754     } catch (std::out_of_range& e) {
27755       {
27756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27757       };
27758     } catch (std::exception& e) {
27759       {
27760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27761       };
27762     } catch (Dali::DaliException e) {
27763       {
27764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27765       };
27766     } catch (...) {
27767       {
27768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27769       };
27770     }
27771   }
27772
27773   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27774   return jresult;
27775 }
27776
27777
27778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27779   int jresult ;
27780   int result;
27781
27782   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27783   jresult = (int)result;
27784   return jresult;
27785 }
27786
27787
27788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27789   int jresult ;
27790   int result;
27791
27792   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27793   jresult = (int)result;
27794   return jresult;
27795 }
27796
27797
27798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27799   int jresult ;
27800   int result;
27801
27802   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
27803   jresult = (int)result;
27804   return jresult;
27805 }
27806
27807
27808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
27809   int jresult ;
27810   int result;
27811
27812   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
27813   jresult = (int)result;
27814   return jresult;
27815 }
27816
27817
27818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
27819   void * jresult ;
27820   Dali::RenderTask::Property *result = 0 ;
27821
27822   {
27823     try {
27824       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
27825     } catch (std::out_of_range& e) {
27826       {
27827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27828       };
27829     } catch (std::exception& e) {
27830       {
27831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27832       };
27833     } catch (Dali::DaliException e) {
27834       {
27835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27836       };
27837     } catch (...) {
27838       {
27839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27840       };
27841     }
27842   }
27843
27844   jresult = (void *)result;
27845   return jresult;
27846 }
27847
27848
27849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
27850   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
27851
27852   arg1 = (Dali::RenderTask::Property *)jarg1;
27853   {
27854     try {
27855       delete arg1;
27856     } catch (std::out_of_range& e) {
27857       {
27858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27859       };
27860     } catch (std::exception& e) {
27861       {
27862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27863       };
27864     } catch (Dali::DaliException e) {
27865       {
27866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27867       };
27868     } catch (...) {
27869       {
27870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27871       };
27872     }
27873   }
27874
27875 }
27876
27877
27878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
27879   void * jresult ;
27880   bool (*result)(Dali::Vector2 &) = 0 ;
27881
27882   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
27883   jresult = (void *)result;
27884   return jresult;
27885 }
27886
27887
27888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
27889   void * jresult ;
27890   bool (*result)(Dali::Vector2 &) = 0 ;
27891
27892   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
27893   jresult = (void *)result;
27894   return jresult;
27895 }
27896
27897
27898 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
27899   unsigned int jresult ;
27900   bool result;
27901
27902   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
27903   jresult = result;
27904   return jresult;
27905 }
27906
27907
27908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
27909   unsigned int jresult ;
27910   bool result;
27911
27912   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
27913   jresult = result;
27914   return jresult;
27915 }
27916
27917
27918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
27919   void * jresult ;
27920   Dali::Vector4 *result = 0 ;
27921
27922   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
27923   jresult = (void *)result;
27924   return jresult;
27925 }
27926
27927
27928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
27929   unsigned int jresult ;
27930   bool result;
27931
27932   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
27933   jresult = result;
27934   return jresult;
27935 }
27936
27937
27938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
27939   unsigned int jresult ;
27940   bool result;
27941
27942   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
27943   jresult = result;
27944   return jresult;
27945 }
27946
27947
27948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
27949   unsigned int jresult ;
27950   unsigned int result;
27951
27952   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
27953   jresult = result;
27954   return jresult;
27955 }
27956
27957
27958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
27959   void * jresult ;
27960   Dali::RenderTask *result = 0 ;
27961
27962   {
27963     try {
27964       result = (Dali::RenderTask *)new Dali::RenderTask();
27965     } catch (std::out_of_range& e) {
27966       {
27967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27968       };
27969     } catch (std::exception& e) {
27970       {
27971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27972       };
27973     } catch (Dali::DaliException e) {
27974       {
27975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27976       };
27977     } catch (...) {
27978       {
27979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27980       };
27981     }
27982   }
27983
27984   jresult = (void *)result;
27985   return jresult;
27986 }
27987
27988
27989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
27990   void * jresult ;
27991   Dali::BaseHandle arg1 ;
27992   Dali::BaseHandle *argp1 ;
27993   Dali::RenderTask result;
27994
27995   argp1 = (Dali::BaseHandle *)jarg1;
27996   if (!argp1) {
27997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27998     return 0;
27999   }
28000   arg1 = *argp1;
28001   {
28002     try {
28003       result = Dali::RenderTask::DownCast(arg1);
28004     } catch (std::out_of_range& e) {
28005       {
28006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28007       };
28008     } catch (std::exception& e) {
28009       {
28010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28011       };
28012     } catch (Dali::DaliException e) {
28013       {
28014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28015       };
28016     } catch (...) {
28017       {
28018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28019       };
28020     }
28021   }
28022
28023   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28024   return jresult;
28025 }
28026
28027
28028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28029   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28030
28031   arg1 = (Dali::RenderTask *)jarg1;
28032   {
28033     try {
28034       delete arg1;
28035     } catch (std::out_of_range& e) {
28036       {
28037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28038       };
28039     } catch (std::exception& e) {
28040       {
28041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28042       };
28043     } catch (Dali::DaliException e) {
28044       {
28045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28046       };
28047     } catch (...) {
28048       {
28049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28050       };
28051     }
28052   }
28053
28054 }
28055
28056
28057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28058   void * jresult ;
28059   Dali::RenderTask *arg1 = 0 ;
28060   Dali::RenderTask *result = 0 ;
28061
28062   arg1 = (Dali::RenderTask *)jarg1;
28063   if (!arg1) {
28064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28065     return 0;
28066   }
28067   {
28068     try {
28069       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28070     } catch (std::out_of_range& e) {
28071       {
28072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28073       };
28074     } catch (std::exception& e) {
28075       {
28076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28077       };
28078     } catch (Dali::DaliException e) {
28079       {
28080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28081       };
28082     } catch (...) {
28083       {
28084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28085       };
28086     }
28087   }
28088
28089   jresult = (void *)result;
28090   return jresult;
28091 }
28092
28093
28094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28095   void * jresult ;
28096   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28097   Dali::RenderTask *arg2 = 0 ;
28098   Dali::RenderTask *result = 0 ;
28099
28100   arg1 = (Dali::RenderTask *)jarg1;
28101   arg2 = (Dali::RenderTask *)jarg2;
28102   if (!arg2) {
28103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28104     return 0;
28105   }
28106   {
28107     try {
28108       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28109     } catch (std::out_of_range& e) {
28110       {
28111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28112       };
28113     } catch (std::exception& e) {
28114       {
28115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28116       };
28117     } catch (Dali::DaliException e) {
28118       {
28119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28120       };
28121     } catch (...) {
28122       {
28123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28124       };
28125     }
28126   }
28127
28128   jresult = (void *)result;
28129   return jresult;
28130 }
28131
28132
28133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28134   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28135   Dali::Actor arg2 ;
28136   Dali::Actor *argp2 ;
28137
28138   arg1 = (Dali::RenderTask *)jarg1;
28139   argp2 = (Dali::Actor *)jarg2;
28140   if (!argp2) {
28141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28142     return ;
28143   }
28144   arg2 = *argp2;
28145   {
28146     try {
28147       (arg1)->SetSourceActor(arg2);
28148     } catch (std::out_of_range& e) {
28149       {
28150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28151       };
28152     } catch (std::exception& e) {
28153       {
28154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28155       };
28156     } catch (Dali::DaliException e) {
28157       {
28158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28159       };
28160     } catch (...) {
28161       {
28162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28163       };
28164     }
28165   }
28166
28167 }
28168
28169
28170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28171   void * jresult ;
28172   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28173   Dali::Actor result;
28174
28175   arg1 = (Dali::RenderTask *)jarg1;
28176   {
28177     try {
28178       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28179     } catch (std::out_of_range& e) {
28180       {
28181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28182       };
28183     } catch (std::exception& e) {
28184       {
28185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28186       };
28187     } catch (Dali::DaliException e) {
28188       {
28189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28190       };
28191     } catch (...) {
28192       {
28193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28194       };
28195     }
28196   }
28197
28198   jresult = new Dali::Actor((const Dali::Actor &)result);
28199   return jresult;
28200 }
28201
28202
28203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28204   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28205   bool arg2 ;
28206
28207   arg1 = (Dali::RenderTask *)jarg1;
28208   arg2 = jarg2 ? true : false;
28209   {
28210     try {
28211       (arg1)->SetExclusive(arg2);
28212     } catch (std::out_of_range& e) {
28213       {
28214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28215       };
28216     } catch (std::exception& e) {
28217       {
28218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28219       };
28220     } catch (Dali::DaliException e) {
28221       {
28222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28223       };
28224     } catch (...) {
28225       {
28226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28227       };
28228     }
28229   }
28230
28231 }
28232
28233
28234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28235   unsigned int jresult ;
28236   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28237   bool result;
28238
28239   arg1 = (Dali::RenderTask *)jarg1;
28240   {
28241     try {
28242       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28243     } catch (std::out_of_range& e) {
28244       {
28245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28246       };
28247     } catch (std::exception& e) {
28248       {
28249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28250       };
28251     } catch (Dali::DaliException e) {
28252       {
28253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28254       };
28255     } catch (...) {
28256       {
28257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28258       };
28259     }
28260   }
28261
28262   jresult = result;
28263   return jresult;
28264 }
28265
28266
28267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28268   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28269   bool arg2 ;
28270
28271   arg1 = (Dali::RenderTask *)jarg1;
28272   arg2 = jarg2 ? true : false;
28273   {
28274     try {
28275       (arg1)->SetInputEnabled(arg2);
28276     } catch (std::out_of_range& e) {
28277       {
28278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28279       };
28280     } catch (std::exception& e) {
28281       {
28282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28283       };
28284     } catch (Dali::DaliException e) {
28285       {
28286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28287       };
28288     } catch (...) {
28289       {
28290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28291       };
28292     }
28293   }
28294
28295 }
28296
28297
28298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28299   unsigned int jresult ;
28300   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28301   bool result;
28302
28303   arg1 = (Dali::RenderTask *)jarg1;
28304   {
28305     try {
28306       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28307     } catch (std::out_of_range& e) {
28308       {
28309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28310       };
28311     } catch (std::exception& e) {
28312       {
28313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28314       };
28315     } catch (Dali::DaliException e) {
28316       {
28317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28318       };
28319     } catch (...) {
28320       {
28321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28322       };
28323     }
28324   }
28325
28326   jresult = result;
28327   return jresult;
28328 }
28329
28330
28331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28332   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28333   Dali::CameraActor arg2 ;
28334   Dali::CameraActor *argp2 ;
28335
28336   arg1 = (Dali::RenderTask *)jarg1;
28337   argp2 = (Dali::CameraActor *)jarg2;
28338   if (!argp2) {
28339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28340     return ;
28341   }
28342   arg2 = *argp2;
28343   {
28344     try {
28345       (arg1)->SetCameraActor(arg2);
28346     } catch (std::out_of_range& e) {
28347       {
28348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28349       };
28350     } catch (std::exception& e) {
28351       {
28352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28353       };
28354     } catch (Dali::DaliException e) {
28355       {
28356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28357       };
28358     } catch (...) {
28359       {
28360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28361       };
28362     }
28363   }
28364
28365 }
28366
28367
28368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28369   void * jresult ;
28370   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28371   Dali::CameraActor result;
28372
28373   arg1 = (Dali::RenderTask *)jarg1;
28374   {
28375     try {
28376       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28377     } catch (std::out_of_range& e) {
28378       {
28379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28380       };
28381     } catch (std::exception& e) {
28382       {
28383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28384       };
28385     } catch (Dali::DaliException e) {
28386       {
28387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28388       };
28389     } catch (...) {
28390       {
28391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28392       };
28393     }
28394   }
28395
28396   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28397   return jresult;
28398 }
28399
28400
28401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28402   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28403   Dali::FrameBuffer arg2 ;
28404   Dali::FrameBuffer *argp2 ;
28405
28406   arg1 = (Dali::RenderTask *)jarg1;
28407   argp2 = (Dali::FrameBuffer *)jarg2;
28408   if (!argp2) {
28409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28410     return ;
28411   }
28412   arg2 = *argp2;
28413   {
28414     try {
28415       (arg1)->SetFrameBuffer(arg2);
28416     } catch (std::out_of_range& e) {
28417       {
28418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28419       };
28420     } catch (std::exception& e) {
28421       {
28422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28423       };
28424     } catch (Dali::DaliException e) {
28425       {
28426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28427       };
28428     } catch (...) {
28429       {
28430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28431       };
28432     }
28433   }
28434
28435 }
28436
28437
28438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28439   void * jresult ;
28440   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28441   Dali::FrameBuffer result;
28442
28443   arg1 = (Dali::RenderTask *)jarg1;
28444   {
28445     try {
28446       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28447     } catch (std::out_of_range& e) {
28448       {
28449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28450       };
28451     } catch (std::exception& e) {
28452       {
28453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28454       };
28455     } catch (Dali::DaliException e) {
28456       {
28457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28458       };
28459     } catch (...) {
28460       {
28461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28462       };
28463     }
28464   }
28465
28466   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28467   return jresult;
28468 }
28469
28470
28471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28472   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28473   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28474
28475   arg1 = (Dali::RenderTask *)jarg1;
28476   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28477   {
28478     try {
28479       (arg1)->SetScreenToFrameBufferFunction(arg2);
28480     } catch (std::out_of_range& e) {
28481       {
28482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28483       };
28484     } catch (std::exception& e) {
28485       {
28486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28487       };
28488     } catch (Dali::DaliException e) {
28489       {
28490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28491       };
28492     } catch (...) {
28493       {
28494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28495       };
28496     }
28497   }
28498
28499 }
28500
28501
28502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28503   void * jresult ;
28504   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28505   Dali::RenderTask::ScreenToFrameBufferFunction result;
28506
28507   arg1 = (Dali::RenderTask *)jarg1;
28508   {
28509     try {
28510       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28511     } catch (std::out_of_range& e) {
28512       {
28513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28514       };
28515     } catch (std::exception& e) {
28516       {
28517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28518       };
28519     } catch (Dali::DaliException e) {
28520       {
28521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28522       };
28523     } catch (...) {
28524       {
28525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28526       };
28527     }
28528   }
28529
28530   jresult = (void *)result;
28531   return jresult;
28532 }
28533
28534
28535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28536   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28537   Dali::Actor arg2 ;
28538   Dali::Actor *argp2 ;
28539
28540   arg1 = (Dali::RenderTask *)jarg1;
28541   argp2 = (Dali::Actor *)jarg2;
28542   if (!argp2) {
28543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28544     return ;
28545   }
28546   arg2 = *argp2;
28547   {
28548     try {
28549       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28550     } catch (std::out_of_range& e) {
28551       {
28552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28553       };
28554     } catch (std::exception& e) {
28555       {
28556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28557       };
28558     } catch (Dali::DaliException e) {
28559       {
28560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28561       };
28562     } catch (...) {
28563       {
28564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28565       };
28566     }
28567   }
28568
28569 }
28570
28571
28572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28573   void * jresult ;
28574   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28575   Dali::Actor result;
28576
28577   arg1 = (Dali::RenderTask *)jarg1;
28578   {
28579     try {
28580       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28581     } catch (std::out_of_range& e) {
28582       {
28583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28584       };
28585     } catch (std::exception& e) {
28586       {
28587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28588       };
28589     } catch (Dali::DaliException e) {
28590       {
28591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28592       };
28593     } catch (...) {
28594       {
28595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28596       };
28597     }
28598   }
28599
28600   jresult = new Dali::Actor((const Dali::Actor &)result);
28601   return jresult;
28602 }
28603
28604
28605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28606   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28607   Dali::Vector2 arg2 ;
28608   Dali::Vector2 *argp2 ;
28609
28610   arg1 = (Dali::RenderTask *)jarg1;
28611   argp2 = (Dali::Vector2 *)jarg2;
28612   if (!argp2) {
28613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28614     return ;
28615   }
28616   arg2 = *argp2;
28617   {
28618     try {
28619       (arg1)->SetViewportPosition(arg2);
28620     } catch (std::out_of_range& e) {
28621       {
28622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28623       };
28624     } catch (std::exception& e) {
28625       {
28626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28627       };
28628     } catch (Dali::DaliException e) {
28629       {
28630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28631       };
28632     } catch (...) {
28633       {
28634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28635       };
28636     }
28637   }
28638
28639 }
28640
28641
28642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28643   void * jresult ;
28644   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28645   Dali::Vector2 result;
28646
28647   arg1 = (Dali::RenderTask *)jarg1;
28648   {
28649     try {
28650       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28651     } catch (std::out_of_range& e) {
28652       {
28653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28654       };
28655     } catch (std::exception& e) {
28656       {
28657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28658       };
28659     } catch (Dali::DaliException e) {
28660       {
28661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28662       };
28663     } catch (...) {
28664       {
28665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28666       };
28667     }
28668   }
28669
28670   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28671   return jresult;
28672 }
28673
28674
28675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28676   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28677   Dali::Vector2 arg2 ;
28678   Dali::Vector2 *argp2 ;
28679
28680   arg1 = (Dali::RenderTask *)jarg1;
28681   argp2 = (Dali::Vector2 *)jarg2;
28682   if (!argp2) {
28683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28684     return ;
28685   }
28686   arg2 = *argp2;
28687   {
28688     try {
28689       (arg1)->SetViewportSize(arg2);
28690     } catch (std::out_of_range& e) {
28691       {
28692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28693       };
28694     } catch (std::exception& e) {
28695       {
28696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28697       };
28698     } catch (Dali::DaliException e) {
28699       {
28700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28701       };
28702     } catch (...) {
28703       {
28704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28705       };
28706     }
28707   }
28708
28709 }
28710
28711
28712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28713   void * jresult ;
28714   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28715   Dali::Vector2 result;
28716
28717   arg1 = (Dali::RenderTask *)jarg1;
28718   {
28719     try {
28720       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28721     } catch (std::out_of_range& e) {
28722       {
28723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28724       };
28725     } catch (std::exception& e) {
28726       {
28727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28728       };
28729     } catch (Dali::DaliException e) {
28730       {
28731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28732       };
28733     } catch (...) {
28734       {
28735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28736       };
28737     }
28738   }
28739
28740   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28741   return jresult;
28742 }
28743
28744
28745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
28746   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28747   Dali::Viewport arg2 ;
28748   Dali::Viewport *argp2 ;
28749
28750   arg1 = (Dali::RenderTask *)jarg1;
28751   argp2 = (Dali::Viewport *)jarg2;
28752   if (!argp2) {
28753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
28754     return ;
28755   }
28756   arg2 = *argp2;
28757   {
28758     try {
28759       (arg1)->SetViewport(arg2);
28760     } catch (std::out_of_range& e) {
28761       {
28762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28763       };
28764     } catch (std::exception& e) {
28765       {
28766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28767       };
28768     } catch (Dali::DaliException e) {
28769       {
28770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28771       };
28772     } catch (...) {
28773       {
28774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28775       };
28776     }
28777   }
28778
28779 }
28780
28781
28782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
28783   void * jresult ;
28784   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28785   Dali::Viewport result;
28786
28787   arg1 = (Dali::RenderTask *)jarg1;
28788   {
28789     try {
28790       result = ((Dali::RenderTask const *)arg1)->GetViewport();
28791     } catch (std::out_of_range& e) {
28792       {
28793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28794       };
28795     } catch (std::exception& e) {
28796       {
28797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28798       };
28799     } catch (Dali::DaliException e) {
28800       {
28801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28802       };
28803     } catch (...) {
28804       {
28805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28806       };
28807     }
28808   }
28809
28810   jresult = new Dali::Viewport((const Dali::Viewport &)result);
28811   return jresult;
28812 }
28813
28814
28815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
28816   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28817   Dali::Vector4 *arg2 = 0 ;
28818
28819   arg1 = (Dali::RenderTask *)jarg1;
28820   arg2 = (Dali::Vector4 *)jarg2;
28821   if (!arg2) {
28822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
28823     return ;
28824   }
28825   {
28826     try {
28827       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
28828     } catch (std::out_of_range& e) {
28829       {
28830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28831       };
28832     } catch (std::exception& e) {
28833       {
28834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28835       };
28836     } catch (Dali::DaliException e) {
28837       {
28838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28839       };
28840     } catch (...) {
28841       {
28842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28843       };
28844     }
28845   }
28846
28847 }
28848
28849
28850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
28851   void * jresult ;
28852   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28853   Dali::Vector4 result;
28854
28855   arg1 = (Dali::RenderTask *)jarg1;
28856   {
28857     try {
28858       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
28859     } catch (std::out_of_range& e) {
28860       {
28861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28862       };
28863     } catch (std::exception& e) {
28864       {
28865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28866       };
28867     } catch (Dali::DaliException e) {
28868       {
28869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28870       };
28871     } catch (...) {
28872       {
28873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28874       };
28875     }
28876   }
28877
28878   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
28879   return jresult;
28880 }
28881
28882
28883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
28884   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28885   bool arg2 ;
28886
28887   arg1 = (Dali::RenderTask *)jarg1;
28888   arg2 = jarg2 ? true : false;
28889   {
28890     try {
28891       (arg1)->SetClearEnabled(arg2);
28892     } catch (std::out_of_range& e) {
28893       {
28894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28895       };
28896     } catch (std::exception& e) {
28897       {
28898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28899       };
28900     } catch (Dali::DaliException e) {
28901       {
28902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28903       };
28904     } catch (...) {
28905       {
28906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28907       };
28908     }
28909   }
28910
28911 }
28912
28913
28914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
28915   unsigned int jresult ;
28916   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28917   bool result;
28918
28919   arg1 = (Dali::RenderTask *)jarg1;
28920   {
28921     try {
28922       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
28923     } catch (std::out_of_range& e) {
28924       {
28925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28926       };
28927     } catch (std::exception& e) {
28928       {
28929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28930       };
28931     } catch (Dali::DaliException e) {
28932       {
28933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28934       };
28935     } catch (...) {
28936       {
28937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28938       };
28939     }
28940   }
28941
28942   jresult = result;
28943   return jresult;
28944 }
28945
28946
28947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
28948   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28949   bool arg2 ;
28950
28951   arg1 = (Dali::RenderTask *)jarg1;
28952   arg2 = jarg2 ? true : false;
28953   {
28954     try {
28955       (arg1)->SetCullMode(arg2);
28956     } catch (std::out_of_range& e) {
28957       {
28958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28959       };
28960     } catch (std::exception& e) {
28961       {
28962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28963       };
28964     } catch (Dali::DaliException e) {
28965       {
28966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28967       };
28968     } catch (...) {
28969       {
28970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28971       };
28972     }
28973   }
28974
28975 }
28976
28977
28978 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
28979   unsigned int jresult ;
28980   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28981   bool result;
28982
28983   arg1 = (Dali::RenderTask *)jarg1;
28984   {
28985     try {
28986       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
28987     } catch (std::out_of_range& e) {
28988       {
28989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28990       };
28991     } catch (std::exception& e) {
28992       {
28993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28994       };
28995     } catch (Dali::DaliException e) {
28996       {
28997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28998       };
28999     } catch (...) {
29000       {
29001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29002       };
29003     }
29004   }
29005
29006   jresult = result;
29007   return jresult;
29008 }
29009
29010
29011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29012   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29013   unsigned int arg2 ;
29014
29015   arg1 = (Dali::RenderTask *)jarg1;
29016   arg2 = (unsigned int)jarg2;
29017   {
29018     try {
29019       (arg1)->SetRefreshRate(arg2);
29020     } catch (std::out_of_range& e) {
29021       {
29022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29023       };
29024     } catch (std::exception& e) {
29025       {
29026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29027       };
29028     } catch (Dali::DaliException e) {
29029       {
29030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29031       };
29032     } catch (...) {
29033       {
29034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29035       };
29036     }
29037   }
29038
29039 }
29040
29041
29042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29043   unsigned int jresult ;
29044   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29045   unsigned int result;
29046
29047   arg1 = (Dali::RenderTask *)jarg1;
29048   {
29049     try {
29050       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29051     } catch (std::out_of_range& e) {
29052       {
29053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29054       };
29055     } catch (std::exception& e) {
29056       {
29057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29058       };
29059     } catch (Dali::DaliException e) {
29060       {
29061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29062       };
29063     } catch (...) {
29064       {
29065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29066       };
29067     }
29068   }
29069
29070   jresult = result;
29071   return jresult;
29072 }
29073
29074
29075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29076   unsigned int jresult ;
29077   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29078   Dali::Vector3 *arg2 = 0 ;
29079   float *arg3 = 0 ;
29080   float *arg4 = 0 ;
29081   bool result;
29082
29083   arg1 = (Dali::RenderTask *)jarg1;
29084   arg2 = (Dali::Vector3 *)jarg2;
29085   if (!arg2) {
29086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29087     return 0;
29088   }
29089   arg3 = (float *)jarg3;
29090   arg4 = (float *)jarg4;
29091   {
29092     try {
29093       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29094     } catch (std::out_of_range& e) {
29095       {
29096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29097       };
29098     } catch (std::exception& e) {
29099       {
29100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29101       };
29102     } catch (Dali::DaliException e) {
29103       {
29104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29105       };
29106     } catch (...) {
29107       {
29108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29109       };
29110     }
29111   }
29112
29113   jresult = result;
29114   return jresult;
29115 }
29116
29117
29118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29119   unsigned int jresult ;
29120   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29121   Dali::Actor arg2 ;
29122   float arg3 ;
29123   float arg4 ;
29124   float *arg5 = 0 ;
29125   float *arg6 = 0 ;
29126   Dali::Actor *argp2 ;
29127   bool result;
29128
29129   arg1 = (Dali::RenderTask *)jarg1;
29130   argp2 = (Dali::Actor *)jarg2;
29131   if (!argp2) {
29132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29133     return 0;
29134   }
29135   arg2 = *argp2;
29136   arg3 = (float)jarg3;
29137   arg4 = (float)jarg4;
29138   arg5 = (float *)jarg5;
29139   arg6 = (float *)jarg6;
29140   {
29141     try {
29142       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29143     } catch (std::out_of_range& e) {
29144       {
29145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29146       };
29147     } catch (std::exception& e) {
29148       {
29149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29150       };
29151     } catch (Dali::DaliException e) {
29152       {
29153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29154       };
29155     } catch (...) {
29156       {
29157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29158       };
29159     }
29160   }
29161
29162   jresult = result;
29163   return jresult;
29164 }
29165
29166
29167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29168   void * jresult ;
29169   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29170   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29171
29172   arg1 = (Dali::RenderTask *)jarg1;
29173   {
29174     try {
29175       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29176     } catch (std::out_of_range& e) {
29177       {
29178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29179       };
29180     } catch (std::exception& e) {
29181       {
29182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29183       };
29184     } catch (Dali::DaliException e) {
29185       {
29186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29187       };
29188     } catch (...) {
29189       {
29190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29191       };
29192     }
29193   }
29194
29195   jresult = (void *)result;
29196   return jresult;
29197 }
29198
29199
29200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29201   void * jresult ;
29202   int arg1 ;
29203   Dali::TouchPoint::State arg2 ;
29204   float arg3 ;
29205   float arg4 ;
29206   Dali::TouchPoint *result = 0 ;
29207
29208   arg1 = (int)jarg1;
29209   arg2 = (Dali::TouchPoint::State)jarg2;
29210   arg3 = (float)jarg3;
29211   arg4 = (float)jarg4;
29212   {
29213     try {
29214       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29215     } catch (std::out_of_range& e) {
29216       {
29217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29218       };
29219     } catch (std::exception& e) {
29220       {
29221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29222       };
29223     } catch (Dali::DaliException e) {
29224       {
29225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29226       };
29227     } catch (...) {
29228       {
29229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29230       };
29231     }
29232   }
29233
29234   jresult = (void *)result;
29235   return jresult;
29236 }
29237
29238
29239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29240   void * jresult ;
29241   int arg1 ;
29242   Dali::TouchPoint::State arg2 ;
29243   float arg3 ;
29244   float arg4 ;
29245   float arg5 ;
29246   float arg6 ;
29247   Dali::TouchPoint *result = 0 ;
29248
29249   arg1 = (int)jarg1;
29250   arg2 = (Dali::TouchPoint::State)jarg2;
29251   arg3 = (float)jarg3;
29252   arg4 = (float)jarg4;
29253   arg5 = (float)jarg5;
29254   arg6 = (float)jarg6;
29255   {
29256     try {
29257       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29258     } catch (std::out_of_range& e) {
29259       {
29260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29261       };
29262     } catch (std::exception& e) {
29263       {
29264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29265       };
29266     } catch (Dali::DaliException e) {
29267       {
29268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29269       };
29270     } catch (...) {
29271       {
29272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29273       };
29274     }
29275   }
29276
29277   jresult = (void *)result;
29278   return jresult;
29279 }
29280
29281
29282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29283   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29284
29285   arg1 = (Dali::TouchPoint *)jarg1;
29286   {
29287     try {
29288       delete arg1;
29289     } catch (std::out_of_range& e) {
29290       {
29291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29292       };
29293     } catch (std::exception& e) {
29294       {
29295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29296       };
29297     } catch (Dali::DaliException e) {
29298       {
29299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29300       };
29301     } catch (...) {
29302       {
29303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29304       };
29305     }
29306   }
29307
29308 }
29309
29310
29311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29312   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29313   int arg2 ;
29314
29315   arg1 = (Dali::TouchPoint *)jarg1;
29316   arg2 = (int)jarg2;
29317   if (arg1) (arg1)->deviceId = arg2;
29318 }
29319
29320
29321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29322   int jresult ;
29323   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29324   int result;
29325
29326   arg1 = (Dali::TouchPoint *)jarg1;
29327   result = (int) ((arg1)->deviceId);
29328   jresult = result;
29329   return jresult;
29330 }
29331
29332
29333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29334   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29335   Dali::TouchPoint::State arg2 ;
29336
29337   arg1 = (Dali::TouchPoint *)jarg1;
29338   arg2 = (Dali::TouchPoint::State)jarg2;
29339   if (arg1) (arg1)->state = arg2;
29340 }
29341
29342
29343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29344   int jresult ;
29345   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29346   Dali::TouchPoint::State result;
29347
29348   arg1 = (Dali::TouchPoint *)jarg1;
29349   result = (Dali::TouchPoint::State) ((arg1)->state);
29350   jresult = (int)result;
29351   return jresult;
29352 }
29353
29354
29355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29356   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29357   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29358
29359   arg1 = (Dali::TouchPoint *)jarg1;
29360   arg2 = (Dali::Actor *)jarg2;
29361   if (arg1) (arg1)->hitActor = *arg2;
29362 }
29363
29364
29365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29366   void * jresult ;
29367   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29368   Dali::Actor *result = 0 ;
29369
29370   arg1 = (Dali::TouchPoint *)jarg1;
29371   result = (Dali::Actor *)& ((arg1)->hitActor);
29372   jresult = (void *)result;
29373   return jresult;
29374 }
29375
29376
29377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29378   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29379   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29380
29381   arg1 = (Dali::TouchPoint *)jarg1;
29382   arg2 = (Dali::Vector2 *)jarg2;
29383   if (arg1) (arg1)->local = *arg2;
29384 }
29385
29386
29387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29388   void * jresult ;
29389   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29390   Dali::Vector2 *result = 0 ;
29391
29392   arg1 = (Dali::TouchPoint *)jarg1;
29393   result = (Dali::Vector2 *)& ((arg1)->local);
29394   jresult = (void *)result;
29395   return jresult;
29396 }
29397
29398
29399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29400   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29401   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29402
29403   arg1 = (Dali::TouchPoint *)jarg1;
29404   arg2 = (Dali::Vector2 *)jarg2;
29405   if (arg1) (arg1)->screen = *arg2;
29406 }
29407
29408
29409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29410   void * jresult ;
29411   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29412   Dali::Vector2 *result = 0 ;
29413
29414   arg1 = (Dali::TouchPoint *)jarg1;
29415   result = (Dali::Vector2 *)& ((arg1)->screen);
29416   jresult = (void *)result;
29417   return jresult;
29418 }
29419
29420
29421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29422   void * jresult ;
29423   Dali::TouchEvent *result = 0 ;
29424
29425   {
29426     try {
29427       result = (Dali::TouchEvent *)new Dali::TouchEvent();
29428     } catch (std::out_of_range& e) {
29429       {
29430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29431       };
29432     } catch (std::exception& e) {
29433       {
29434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29435       };
29436     } catch (Dali::DaliException e) {
29437       {
29438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29439       };
29440     } catch (...) {
29441       {
29442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29443       };
29444     }
29445   }
29446
29447   jresult = (void *)result;
29448   return jresult;
29449 }
29450
29451
29452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29453   void * jresult ;
29454   Dali::TouchEvent *arg1 = 0 ;
29455   Dali::TouchEvent *result = 0 ;
29456
29457   arg1 = (Dali::TouchEvent *)jarg1;
29458   if (!arg1) {
29459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
29460     return 0;
29461   }
29462   {
29463     try {
29464       result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1);
29465     } catch (std::out_of_range& e) {
29466       {
29467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29468       };
29469     } catch (std::exception& e) {
29470       {
29471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29472       };
29473     } catch (Dali::DaliException e) {
29474       {
29475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29476       };
29477     } catch (...) {
29478       {
29479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29480       };
29481     }
29482   }
29483
29484   jresult = (void *)result;
29485   return jresult;
29486 }
29487
29488
29489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29490   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29491
29492   arg1 = (Dali::TouchEvent *)jarg1;
29493   {
29494     try {
29495       delete arg1;
29496     } catch (std::out_of_range& e) {
29497       {
29498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29499       };
29500     } catch (std::exception& e) {
29501       {
29502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29503       };
29504     } catch (Dali::DaliException e) {
29505       {
29506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29507       };
29508     } catch (...) {
29509       {
29510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29511       };
29512     }
29513   }
29514
29515 }
29516
29517
29518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29519   void * jresult ;
29520   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29521   Dali::TouchEvent *arg2 = 0 ;
29522   Dali::TouchEvent *result = 0 ;
29523
29524   arg1 = (Dali::TouchEvent *)jarg1;
29525   arg2 = (Dali::TouchEvent *)jarg2;
29526   if (!arg2) {
29527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
29528     return 0;
29529   }
29530   {
29531     try {
29532       result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2);
29533     } catch (std::out_of_range& e) {
29534       {
29535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29536       };
29537     } catch (std::exception& e) {
29538       {
29539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29540       };
29541     } catch (Dali::DaliException e) {
29542       {
29543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29544       };
29545     } catch (...) {
29546       {
29547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29548       };
29549     }
29550   }
29551
29552   jresult = (void *)result;
29553   return jresult;
29554 }
29555
29556
29557 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29558   unsigned long jresult ;
29559   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29560   unsigned long result;
29561
29562   arg1 = (Dali::TouchEvent *)jarg1;
29563   {
29564     try {
29565       result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime();
29566     } catch (std::out_of_range& e) {
29567       {
29568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29569       };
29570     } catch (std::exception& e) {
29571       {
29572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29573       };
29574     } catch (Dali::DaliException e) {
29575       {
29576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29577       };
29578     } catch (...) {
29579       {
29580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29581       };
29582     }
29583   }
29584
29585   jresult = (unsigned long)result;
29586   return jresult;
29587 }
29588
29589
29590 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29591   unsigned long jresult ;
29592   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29593   std::size_t result;
29594
29595   arg1 = (Dali::TouchEvent *)jarg1;
29596   {
29597     try {
29598       result = ((Dali::TouchEvent const *)arg1)->GetPointCount();
29599     } catch (std::out_of_range& e) {
29600       {
29601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29602       };
29603     } catch (std::exception& e) {
29604       {
29605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29606       };
29607     } catch (Dali::DaliException e) {
29608       {
29609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29610       };
29611     } catch (...) {
29612       {
29613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29614       };
29615     }
29616   }
29617
29618   jresult = (unsigned long)result;
29619   return jresult;
29620 }
29621
29622
29623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29624   int jresult ;
29625   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29626   std::size_t arg2 ;
29627   int32_t result;
29628
29629   arg1 = (Dali::TouchEvent *)jarg1;
29630   arg2 = (std::size_t)jarg2;
29631   {
29632     try {
29633       result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2);
29634     } catch (std::out_of_range& e) {
29635       {
29636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29637       };
29638     } catch (std::exception& e) {
29639       {
29640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29641       };
29642     } catch (Dali::DaliException e) {
29643       {
29644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29645       };
29646     } catch (...) {
29647       {
29648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29649       };
29650     }
29651   }
29652
29653   jresult = result;
29654   return jresult;
29655 }
29656
29657
29658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29659   int jresult ;
29660   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29661   std::size_t arg2 ;
29662   Dali::PointState::Type result;
29663
29664   arg1 = (Dali::TouchEvent *)jarg1;
29665   arg2 = (std::size_t)jarg2;
29666   {
29667     try {
29668       result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2);
29669     } catch (std::out_of_range& e) {
29670       {
29671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29672       };
29673     } catch (std::exception& e) {
29674       {
29675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29676       };
29677     } catch (Dali::DaliException e) {
29678       {
29679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29680       };
29681     } catch (...) {
29682       {
29683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29684       };
29685     }
29686   }
29687
29688   jresult = (int)result;
29689   return jresult;
29690 }
29691
29692
29693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29694   void * jresult ;
29695   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29696   std::size_t arg2 ;
29697   Dali::Actor result;
29698
29699   arg1 = (Dali::TouchEvent *)jarg1;
29700   arg2 = (std::size_t)jarg2;
29701   {
29702     try {
29703       result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2);
29704     } catch (std::out_of_range& e) {
29705       {
29706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29707       };
29708     } catch (std::exception& e) {
29709       {
29710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29711       };
29712     } catch (Dali::DaliException e) {
29713       {
29714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29715       };
29716     } catch (...) {
29717       {
29718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29719       };
29720     }
29721   }
29722
29723   jresult = new Dali::Actor((const Dali::Actor &)result);
29724   return jresult;
29725 }
29726
29727
29728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29729   void * jresult ;
29730   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29731   std::size_t arg2 ;
29732   Dali::Vector2 *result = 0 ;
29733
29734   arg1 = (Dali::TouchEvent *)jarg1;
29735   arg2 = (std::size_t)jarg2;
29736   {
29737     try {
29738       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2);
29739     } catch (std::out_of_range& e) {
29740       {
29741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29742       };
29743     } catch (std::exception& e) {
29744       {
29745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29746       };
29747     } catch (Dali::DaliException e) {
29748       {
29749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29750       };
29751     } catch (...) {
29752       {
29753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29754       };
29755     }
29756   }
29757
29758   jresult = (void *)result;
29759   return jresult;
29760 }
29761
29762
29763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
29764   void * jresult ;
29765   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29766   std::size_t arg2 ;
29767   Dali::Vector2 *result = 0 ;
29768
29769   arg1 = (Dali::TouchEvent *)jarg1;
29770   arg2 = (std::size_t)jarg2;
29771   {
29772     try {
29773       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2);
29774     } catch (std::out_of_range& e) {
29775       {
29776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29777       };
29778     } catch (std::exception& e) {
29779       {
29780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29781       };
29782     } catch (Dali::DaliException e) {
29783       {
29784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29785       };
29786     } catch (...) {
29787       {
29788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29789       };
29790     }
29791   }
29792
29793   jresult = (void *)result;
29794   return jresult;
29795 }
29796
29797
29798 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
29799   float jresult ;
29800   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29801   std::size_t arg2 ;
29802   float result;
29803
29804   arg1 = (Dali::TouchEvent *)jarg1;
29805   arg2 = (std::size_t)jarg2;
29806   {
29807     try {
29808       result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2);
29809     } catch (std::out_of_range& e) {
29810       {
29811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29812       };
29813     } catch (std::exception& e) {
29814       {
29815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29816       };
29817     } catch (Dali::DaliException e) {
29818       {
29819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29820       };
29821     } catch (...) {
29822       {
29823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29824       };
29825     }
29826   }
29827
29828   jresult = result;
29829   return jresult;
29830 }
29831
29832
29833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
29834   void * jresult ;
29835   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29836   std::size_t arg2 ;
29837   Dali::Vector2 *result = 0 ;
29838
29839   arg1 = (Dali::TouchEvent *)jarg1;
29840   arg2 = (std::size_t)jarg2;
29841   {
29842     try {
29843       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2);
29844     } catch (std::out_of_range& e) {
29845       {
29846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29847       };
29848     } catch (std::exception& e) {
29849       {
29850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29851       };
29852     } catch (Dali::DaliException e) {
29853       {
29854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29855       };
29856     } catch (...) {
29857       {
29858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29859       };
29860     }
29861   }
29862
29863   jresult = (void *)result;
29864   return jresult;
29865 }
29866
29867
29868 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
29869   float jresult ;
29870   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29871   std::size_t arg2 ;
29872   float result;
29873
29874   arg1 = (Dali::TouchEvent *)jarg1;
29875   arg2 = (std::size_t)jarg2;
29876   {
29877     try {
29878       result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2);
29879     } catch (std::out_of_range& e) {
29880       {
29881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29882       };
29883     } catch (std::exception& e) {
29884       {
29885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29886       };
29887     } catch (Dali::DaliException e) {
29888       {
29889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29890       };
29891     } catch (...) {
29892       {
29893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29894       };
29895     }
29896   }
29897
29898   jresult = result;
29899   return jresult;
29900 }
29901
29902
29903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
29904   void * jresult ;
29905   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29906   std::size_t arg2 ;
29907   Dali::Degree result;
29908
29909   arg1 = (Dali::TouchEvent *)jarg1;
29910   arg2 = (std::size_t)jarg2;
29911   {
29912     try {
29913       result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2);
29914     } catch (std::out_of_range& e) {
29915       {
29916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29917       };
29918     } catch (std::exception& e) {
29919       {
29920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29921       };
29922     } catch (Dali::DaliException e) {
29923       {
29924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29925       };
29926     } catch (...) {
29927       {
29928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29929       };
29930     }
29931   }
29932
29933   jresult = new Dali::Degree((const Dali::Degree &)result);
29934   return jresult;
29935 }
29936
29937
29938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
29939   int jresult ;
29940   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29941   std::size_t arg2 ;
29942   Dali::MouseButton::Type result;
29943
29944   arg1 = (Dali::TouchEvent *)jarg1;
29945   arg2 = (std::size_t)jarg2;
29946   {
29947     try {
29948       result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2);
29949     } catch (std::out_of_range& e) {
29950       {
29951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29952       };
29953     } catch (std::exception& e) {
29954       {
29955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29956       };
29957     } catch (Dali::DaliException e) {
29958       {
29959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29960       };
29961     } catch (...) {
29962       {
29963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29964       };
29965     }
29966   }
29967
29968   jresult = static_cast< int >(result);
29969   return jresult;
29970 }
29971
29972
29973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
29974   void * jresult ;
29975   Dali::GestureDetector *result = 0 ;
29976
29977   {
29978     try {
29979       result = (Dali::GestureDetector *)new Dali::GestureDetector();
29980     } catch (std::out_of_range& e) {
29981       {
29982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29983       };
29984     } catch (std::exception& e) {
29985       {
29986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29987       };
29988     } catch (Dali::DaliException e) {
29989       {
29990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29991       };
29992     } catch (...) {
29993       {
29994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29995       };
29996     }
29997   }
29998
29999   jresult = (void *)result;
30000   return jresult;
30001 }
30002
30003
30004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30005   void * jresult ;
30006   Dali::BaseHandle arg1 ;
30007   Dali::BaseHandle *argp1 ;
30008   Dali::GestureDetector result;
30009
30010   argp1 = (Dali::BaseHandle *)jarg1;
30011   if (!argp1) {
30012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30013     return 0;
30014   }
30015   arg1 = *argp1;
30016   {
30017     try {
30018       result = Dali::GestureDetector::DownCast(arg1);
30019     } catch (std::out_of_range& e) {
30020       {
30021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30022       };
30023     } catch (std::exception& e) {
30024       {
30025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30026       };
30027     } catch (Dali::DaliException e) {
30028       {
30029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30030       };
30031     } catch (...) {
30032       {
30033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30034       };
30035     }
30036   }
30037
30038   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30039   return jresult;
30040 }
30041
30042
30043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30044   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30045
30046   arg1 = (Dali::GestureDetector *)jarg1;
30047   {
30048     try {
30049       delete arg1;
30050     } catch (std::out_of_range& e) {
30051       {
30052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30053       };
30054     } catch (std::exception& e) {
30055       {
30056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30057       };
30058     } catch (Dali::DaliException e) {
30059       {
30060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30061       };
30062     } catch (...) {
30063       {
30064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30065       };
30066     }
30067   }
30068
30069 }
30070
30071
30072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30073   void * jresult ;
30074   Dali::GestureDetector *arg1 = 0 ;
30075   Dali::GestureDetector *result = 0 ;
30076
30077   arg1 = (Dali::GestureDetector *)jarg1;
30078   if (!arg1) {
30079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30080     return 0;
30081   }
30082   {
30083     try {
30084       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30085     } catch (std::out_of_range& e) {
30086       {
30087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30088       };
30089     } catch (std::exception& e) {
30090       {
30091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30092       };
30093     } catch (Dali::DaliException e) {
30094       {
30095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30096       };
30097     } catch (...) {
30098       {
30099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30100       };
30101     }
30102   }
30103
30104   jresult = (void *)result;
30105   return jresult;
30106 }
30107
30108
30109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30110   void * jresult ;
30111   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30112   Dali::GestureDetector *arg2 = 0 ;
30113   Dali::GestureDetector *result = 0 ;
30114
30115   arg1 = (Dali::GestureDetector *)jarg1;
30116   arg2 = (Dali::GestureDetector *)jarg2;
30117   if (!arg2) {
30118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30119     return 0;
30120   }
30121   {
30122     try {
30123       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30124     } catch (std::out_of_range& e) {
30125       {
30126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30127       };
30128     } catch (std::exception& e) {
30129       {
30130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30131       };
30132     } catch (Dali::DaliException e) {
30133       {
30134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30135       };
30136     } catch (...) {
30137       {
30138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30139       };
30140     }
30141   }
30142
30143   jresult = (void *)result;
30144   return jresult;
30145 }
30146
30147
30148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30149   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30150   Dali::Actor arg2 ;
30151   Dali::Actor *argp2 ;
30152
30153   arg1 = (Dali::GestureDetector *)jarg1;
30154   argp2 = (Dali::Actor *)jarg2;
30155   if (!argp2) {
30156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30157     return ;
30158   }
30159   arg2 = *argp2;
30160   {
30161     try {
30162       (arg1)->Attach(arg2);
30163     } catch (std::out_of_range& e) {
30164       {
30165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30166       };
30167     } catch (std::exception& e) {
30168       {
30169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30170       };
30171     } catch (Dali::DaliException e) {
30172       {
30173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30174       };
30175     } catch (...) {
30176       {
30177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30178       };
30179     }
30180   }
30181
30182 }
30183
30184
30185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30186   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30187   Dali::Actor arg2 ;
30188   Dali::Actor *argp2 ;
30189
30190   arg1 = (Dali::GestureDetector *)jarg1;
30191   argp2 = (Dali::Actor *)jarg2;
30192   if (!argp2) {
30193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30194     return ;
30195   }
30196   arg2 = *argp2;
30197   {
30198     try {
30199       (arg1)->Detach(arg2);
30200     } catch (std::out_of_range& e) {
30201       {
30202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30203       };
30204     } catch (std::exception& e) {
30205       {
30206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30207       };
30208     } catch (Dali::DaliException e) {
30209       {
30210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30211       };
30212     } catch (...) {
30213       {
30214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30215       };
30216     }
30217   }
30218
30219 }
30220
30221
30222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30223   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30224
30225   arg1 = (Dali::GestureDetector *)jarg1;
30226   {
30227     try {
30228       (arg1)->DetachAll();
30229     } catch (std::out_of_range& e) {
30230       {
30231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30232       };
30233     } catch (std::exception& e) {
30234       {
30235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30236       };
30237     } catch (Dali::DaliException e) {
30238       {
30239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30240       };
30241     } catch (...) {
30242       {
30243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30244       };
30245     }
30246   }
30247
30248 }
30249
30250
30251 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30252   unsigned long jresult ;
30253   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30254   size_t result;
30255
30256   arg1 = (Dali::GestureDetector *)jarg1;
30257   {
30258     try {
30259       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30260     } catch (std::out_of_range& e) {
30261       {
30262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30263       };
30264     } catch (std::exception& e) {
30265       {
30266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30267       };
30268     } catch (Dali::DaliException e) {
30269       {
30270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30271       };
30272     } catch (...) {
30273       {
30274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30275       };
30276     }
30277   }
30278
30279   jresult = (unsigned long)result;
30280   return jresult;
30281 }
30282
30283
30284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30285   void * jresult ;
30286   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30287   size_t arg2 ;
30288   Dali::Actor result;
30289
30290   arg1 = (Dali::GestureDetector *)jarg1;
30291   arg2 = (size_t)jarg2;
30292   {
30293     try {
30294       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30295     } catch (std::out_of_range& e) {
30296       {
30297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30298       };
30299     } catch (std::exception& e) {
30300       {
30301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30302       };
30303     } catch (Dali::DaliException e) {
30304       {
30305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30306       };
30307     } catch (...) {
30308       {
30309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30310       };
30311     }
30312   }
30313
30314   jresult = new Dali::Actor((const Dali::Actor &)result);
30315   return jresult;
30316 }
30317
30318
30319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30320   void * jresult ;
30321   Dali::Gesture *arg1 = 0 ;
30322   Dali::Gesture *result = 0 ;
30323
30324   arg1 = (Dali::Gesture *)jarg1;
30325   if (!arg1) {
30326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30327     return 0;
30328   }
30329   {
30330     try {
30331       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30332     } catch (std::out_of_range& e) {
30333       {
30334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30335       };
30336     } catch (std::exception& e) {
30337       {
30338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30339       };
30340     } catch (Dali::DaliException e) {
30341       {
30342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30343       };
30344     } catch (...) {
30345       {
30346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30347       };
30348     }
30349   }
30350
30351   jresult = (void *)result;
30352   return jresult;
30353 }
30354
30355
30356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30357   void * jresult ;
30358   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30359   Dali::Gesture *arg2 = 0 ;
30360   Dali::Gesture *result = 0 ;
30361
30362   arg1 = (Dali::Gesture *)jarg1;
30363   arg2 = (Dali::Gesture *)jarg2;
30364   if (!arg2) {
30365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30366     return 0;
30367   }
30368   {
30369     try {
30370       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30371     } catch (std::out_of_range& e) {
30372       {
30373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30374       };
30375     } catch (std::exception& e) {
30376       {
30377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30378       };
30379     } catch (Dali::DaliException e) {
30380       {
30381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30382       };
30383     } catch (...) {
30384       {
30385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30386       };
30387     }
30388   }
30389
30390   jresult = (void *)result;
30391   return jresult;
30392 }
30393
30394
30395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30396   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30397
30398   arg1 = (Dali::Gesture *)jarg1;
30399   {
30400     try {
30401       delete arg1;
30402     } catch (std::out_of_range& e) {
30403       {
30404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30405       };
30406     } catch (std::exception& e) {
30407       {
30408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30409       };
30410     } catch (Dali::DaliException e) {
30411       {
30412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30413       };
30414     } catch (...) {
30415       {
30416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30417       };
30418     }
30419   }
30420
30421 }
30422
30423
30424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30425   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30426   Dali::Gesture::Type arg2 ;
30427
30428   arg1 = (Dali::Gesture *)jarg1;
30429   arg2 = (Dali::Gesture::Type)jarg2;
30430   if (arg1) (arg1)->type = arg2;
30431 }
30432
30433
30434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30435   int jresult ;
30436   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30437   Dali::Gesture::Type result;
30438
30439   arg1 = (Dali::Gesture *)jarg1;
30440   result = (Dali::Gesture::Type) ((arg1)->type);
30441   jresult = (int)result;
30442   return jresult;
30443 }
30444
30445
30446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30447   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30448   Dali::Gesture::State arg2 ;
30449
30450   arg1 = (Dali::Gesture *)jarg1;
30451   arg2 = (Dali::Gesture::State)jarg2;
30452   if (arg1) (arg1)->state = arg2;
30453 }
30454
30455
30456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30457   int jresult ;
30458   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30459   Dali::Gesture::State result;
30460
30461   arg1 = (Dali::Gesture *)jarg1;
30462   result = (Dali::Gesture::State) ((arg1)->state);
30463   jresult = (int)result;
30464   return jresult;
30465 }
30466
30467
30468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30469   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30470   unsigned int arg2 ;
30471
30472   arg1 = (Dali::Gesture *)jarg1;
30473   arg2 = (unsigned int)jarg2;
30474   if (arg1) (arg1)->time = arg2;
30475 }
30476
30477
30478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30479   unsigned int jresult ;
30480   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30481   unsigned int result;
30482
30483   arg1 = (Dali::Gesture *)jarg1;
30484   result = (unsigned int) ((arg1)->time);
30485   jresult = result;
30486   return jresult;
30487 }
30488
30489
30490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30491   void * jresult ;
30492   Dali::HoverEvent *result = 0 ;
30493
30494   {
30495     try {
30496       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30497     } catch (std::out_of_range& e) {
30498       {
30499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30500       };
30501     } catch (std::exception& e) {
30502       {
30503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30504       };
30505     } catch (Dali::DaliException e) {
30506       {
30507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30508       };
30509     } catch (...) {
30510       {
30511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30512       };
30513     }
30514   }
30515
30516   jresult = (void *)result;
30517   return jresult;
30518 }
30519
30520
30521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) {
30522   void * jresult ;
30523   Dali::HoverEvent *arg1 = 0 ;
30524   Dali::HoverEvent *result = 0 ;
30525
30526   arg1 = (Dali::HoverEvent *)jarg1;
30527   if (!arg1) {
30528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
30529     return 0;
30530   }
30531   {
30532     try {
30533       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
30534     } catch (std::out_of_range& e) {
30535       {
30536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30537       };
30538     } catch (std::exception& e) {
30539       {
30540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30541       };
30542     } catch (Dali::DaliException e) {
30543       {
30544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30545       };
30546     } catch (...) {
30547       {
30548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30549       };
30550     }
30551   }
30552
30553   jresult = (void *)result;
30554   return jresult;
30555 }
30556
30557
30558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30559   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30560
30561   arg1 = (Dali::HoverEvent *)jarg1;
30562   {
30563     try {
30564       delete arg1;
30565     } catch (std::out_of_range& e) {
30566       {
30567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30568       };
30569     } catch (std::exception& e) {
30570       {
30571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30572       };
30573     } catch (Dali::DaliException e) {
30574       {
30575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30576       };
30577     } catch (...) {
30578       {
30579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30580       };
30581     }
30582   }
30583
30584 }
30585
30586
30587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) {
30588   void * jresult ;
30589   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30590   Dali::HoverEvent *arg2 = 0 ;
30591   Dali::HoverEvent *result = 0 ;
30592
30593   arg1 = (Dali::HoverEvent *)jarg1;
30594   arg2 = (Dali::HoverEvent *)jarg2;
30595   if (!arg2) {
30596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
30597     return 0;
30598   }
30599   {
30600     try {
30601       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
30602     } catch (std::out_of_range& e) {
30603       {
30604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30605       };
30606     } catch (std::exception& e) {
30607       {
30608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30609       };
30610     } catch (Dali::DaliException e) {
30611       {
30612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30613       };
30614     } catch (...) {
30615       {
30616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30617       };
30618     }
30619   }
30620
30621   jresult = (void *)result;
30622   return jresult;
30623 }
30624
30625
30626 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
30627   unsigned long jresult ;
30628   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30629   unsigned long result;
30630
30631   arg1 = (Dali::HoverEvent *)jarg1;
30632   {
30633     try {
30634       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
30635     } catch (std::out_of_range& e) {
30636       {
30637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30638       };
30639     } catch (std::exception& e) {
30640       {
30641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30642       };
30643     } catch (Dali::DaliException e) {
30644       {
30645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30646       };
30647     } catch (...) {
30648       {
30649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30650       };
30651     }
30652   }
30653
30654   jresult = (unsigned long)result;
30655   return jresult;
30656 }
30657
30658
30659 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30660   unsigned long jresult ;
30661   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30662   std::size_t result;
30663
30664   arg1 = (Dali::HoverEvent *)jarg1;
30665   {
30666     try {
30667       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
30668     } catch (std::out_of_range& e) {
30669       {
30670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30671       };
30672     } catch (std::exception& e) {
30673       {
30674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30675       };
30676     } catch (Dali::DaliException e) {
30677       {
30678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30679       };
30680     } catch (...) {
30681       {
30682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30683       };
30684     }
30685   }
30686
30687   jresult = (unsigned long)result;
30688   return jresult;
30689 }
30690
30691
30692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
30693   int jresult ;
30694   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30695   std::size_t arg2 ;
30696   int32_t result;
30697
30698   arg1 = (Dali::HoverEvent *)jarg1;
30699   arg2 = (std::size_t)jarg2;
30700   {
30701     try {
30702       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
30703     } catch (std::out_of_range& e) {
30704       {
30705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30706       };
30707     } catch (std::exception& e) {
30708       {
30709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30710       };
30711     } catch (Dali::DaliException e) {
30712       {
30713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30714       };
30715     } catch (...) {
30716       {
30717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30718       };
30719     }
30720   }
30721
30722   jresult = result;
30723   return jresult;
30724 }
30725
30726
30727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
30728   int jresult ;
30729   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30730   std::size_t arg2 ;
30731   Dali::PointState::Type result;
30732
30733   arg1 = (Dali::HoverEvent *)jarg1;
30734   arg2 = (std::size_t)jarg2;
30735   {
30736     try {
30737       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
30738     } catch (std::out_of_range& e) {
30739       {
30740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30741       };
30742     } catch (std::exception& e) {
30743       {
30744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30745       };
30746     } catch (Dali::DaliException e) {
30747       {
30748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30749       };
30750     } catch (...) {
30751       {
30752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30753       };
30754     }
30755   }
30756
30757   jresult = (int)result;
30758   return jresult;
30759 }
30760
30761
30762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
30763   void * jresult ;
30764   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30765   std::size_t arg2 ;
30766   Dali::Actor result;
30767
30768   arg1 = (Dali::HoverEvent *)jarg1;
30769   arg2 = (std::size_t)jarg2;
30770   {
30771     try {
30772       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
30773     } catch (std::out_of_range& e) {
30774       {
30775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30776       };
30777     } catch (std::exception& e) {
30778       {
30779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30780       };
30781     } catch (Dali::DaliException e) {
30782       {
30783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30784       };
30785     } catch (...) {
30786       {
30787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30788       };
30789     }
30790   }
30791
30792   jresult = new Dali::Actor((const Dali::Actor &)result);
30793   return jresult;
30794 }
30795
30796
30797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30798   void * jresult ;
30799   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30800   std::size_t arg2 ;
30801   Dali::Vector2 *result = 0 ;
30802
30803   arg1 = (Dali::HoverEvent *)jarg1;
30804   arg2 = (std::size_t)jarg2;
30805   {
30806     try {
30807       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
30808     } catch (std::out_of_range& e) {
30809       {
30810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30811       };
30812     } catch (std::exception& e) {
30813       {
30814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30815       };
30816     } catch (Dali::DaliException e) {
30817       {
30818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30819       };
30820     } catch (...) {
30821       {
30822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30823       };
30824     }
30825   }
30826
30827   jresult = (void *)result;
30828   return jresult;
30829 }
30830
30831
30832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30833   void * jresult ;
30834   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30835   std::size_t arg2 ;
30836   Dali::Vector2 *result = 0 ;
30837
30838   arg1 = (Dali::HoverEvent *)jarg1;
30839   arg2 = (std::size_t)jarg2;
30840   {
30841     try {
30842       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
30843     } catch (std::out_of_range& e) {
30844       {
30845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30846       };
30847     } catch (std::exception& e) {
30848       {
30849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30850       };
30851     } catch (Dali::DaliException e) {
30852       {
30853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30854       };
30855     } catch (...) {
30856       {
30857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30858       };
30859     }
30860   }
30861
30862   jresult = (void *)result;
30863   return jresult;
30864 }
30865
30866
30867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30868   void * jresult ;
30869   Dali::KeyEvent *result = 0 ;
30870
30871   {
30872     try {
30873       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30874     } catch (std::out_of_range& e) {
30875       {
30876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30877       };
30878     } catch (std::exception& e) {
30879       {
30880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30881       };
30882     } catch (Dali::DaliException e) {
30883       {
30884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30885       };
30886     } catch (...) {
30887       {
30888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30889       };
30890     }
30891   }
30892
30893   jresult = (void *)result;
30894   return jresult;
30895 }
30896
30897
30898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30899   void * jresult ;
30900   std::string *arg1 = 0 ;
30901   std::string *arg2 = 0 ;
30902   int arg3 ;
30903   int arg4 ;
30904   unsigned long arg5 ;
30905   Dali::KeyEvent::State *arg6 = 0 ;
30906   Dali::KeyEvent::State temp6 ;
30907   Dali::KeyEvent *result = 0 ;
30908
30909   if (!jarg1) {
30910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30911     return 0;
30912   }
30913   std::string arg1_str(jarg1);
30914   arg1 = &arg1_str;
30915   if (!jarg2) {
30916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30917     return 0;
30918   }
30919   std::string arg2_str(jarg2);
30920   arg2 = &arg2_str;
30921   arg3 = (int)jarg3;
30922   arg4 = (int)jarg4;
30923   arg5 = (unsigned long)jarg5;
30924   temp6 = (Dali::KeyEvent::State)jarg6;
30925   arg6 = &temp6;
30926   {
30927     try {
30928       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
30929     } catch (std::out_of_range& e) {
30930       {
30931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30932       };
30933     } catch (std::exception& e) {
30934       {
30935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30936       };
30937     } catch (Dali::DaliException e) {
30938       {
30939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30940       };
30941     } catch (...) {
30942       {
30943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30944       };
30945     }
30946   }
30947
30948   jresult = (void *)result;
30949
30950   //argout typemap for const std::string&
30951
30952
30953   //argout typemap for const std::string&
30954
30955   return jresult;
30956 }
30957
30958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
30959   void * jresult ;
30960   Dali::KeyEvent *arg1 = 0 ;
30961   Dali::KeyEvent *result = 0 ;
30962
30963   arg1 = (Dali::KeyEvent *)jarg1;
30964   if (!arg1) {
30965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30966     return 0;
30967   }
30968   {
30969     try {
30970       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
30971     } catch (std::out_of_range& e) {
30972       {
30973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30974       };
30975     } catch (std::exception& e) {
30976       {
30977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30978       };
30979     } catch (Dali::DaliException e) {
30980       {
30981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30982       };
30983     } catch (...) {
30984       {
30985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30986       };
30987     }
30988   }
30989
30990   jresult = (void *)result;
30991   return jresult;
30992 }
30993
30994
30995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
30996   void * jresult ;
30997   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30998   Dali::KeyEvent *arg2 = 0 ;
30999   Dali::KeyEvent *result = 0 ;
31000
31001   arg1 = (Dali::KeyEvent *)jarg1;
31002   arg2 = (Dali::KeyEvent *)jarg2;
31003   if (!arg2) {
31004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31005     return 0;
31006   }
31007   {
31008     try {
31009       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31010     } catch (std::out_of_range& e) {
31011       {
31012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31013       };
31014     } catch (std::exception& e) {
31015       {
31016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31017       };
31018     } catch (Dali::DaliException e) {
31019       {
31020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31021       };
31022     } catch (...) {
31023       {
31024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31025       };
31026     }
31027   }
31028
31029   jresult = (void *)result;
31030   return jresult;
31031 }
31032
31033
31034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31035   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31036
31037   arg1 = (Dali::KeyEvent *)jarg1;
31038   {
31039     try {
31040       delete arg1;
31041     } catch (std::out_of_range& e) {
31042       {
31043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31044       };
31045     } catch (std::exception& e) {
31046       {
31047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31048       };
31049     } catch (Dali::DaliException e) {
31050       {
31051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31052       };
31053     } catch (...) {
31054       {
31055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31056       };
31057     }
31058   }
31059
31060 }
31061
31062
31063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31064   unsigned int jresult ;
31065   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31066   bool result;
31067
31068   arg1 = (Dali::KeyEvent *)jarg1;
31069   {
31070     try {
31071       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31072     } catch (std::out_of_range& e) {
31073       {
31074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31075       };
31076     } catch (std::exception& e) {
31077       {
31078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31079       };
31080     } catch (Dali::DaliException e) {
31081       {
31082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31083       };
31084     } catch (...) {
31085       {
31086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31087       };
31088     }
31089   }
31090
31091   jresult = result;
31092   return jresult;
31093 }
31094
31095
31096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31097   unsigned int jresult ;
31098   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31099   bool result;
31100
31101   arg1 = (Dali::KeyEvent *)jarg1;
31102   {
31103     try {
31104       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31105     } catch (std::out_of_range& e) {
31106       {
31107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31108       };
31109     } catch (std::exception& e) {
31110       {
31111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31112       };
31113     } catch (Dali::DaliException e) {
31114       {
31115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31116       };
31117     } catch (...) {
31118       {
31119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31120       };
31121     }
31122   }
31123
31124   jresult = result;
31125   return jresult;
31126 }
31127
31128
31129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31130   unsigned int jresult ;
31131   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31132   bool result;
31133
31134   arg1 = (Dali::KeyEvent *)jarg1;
31135   {
31136     try {
31137       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31138     } catch (std::out_of_range& e) {
31139       {
31140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31141       };
31142     } catch (std::exception& e) {
31143       {
31144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31145       };
31146     } catch (Dali::DaliException e) {
31147       {
31148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31149       };
31150     } catch (...) {
31151       {
31152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31153       };
31154     }
31155   }
31156
31157   jresult = result;
31158   return jresult;
31159 }
31160
31161
31162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31163   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31164   std::string *arg2 = 0 ;
31165
31166   arg1 = (Dali::KeyEvent *)jarg1;
31167   if (!jarg2) {
31168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31169     return ;
31170   }
31171   std::string arg2_str(jarg2);
31172   arg2 = &arg2_str;
31173   if (arg1) (arg1)->keyPressedName = *arg2;
31174
31175   //argout typemap for const std::string&
31176
31177 }
31178
31179
31180 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31181   char * jresult ;
31182
31183   if( jarg1 == NULL )
31184   {
31185     jresult = SWIG_csharp_string_callback( "" );
31186   }
31187   else
31188   {
31189     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31190     std::string *result = 0;
31191
31192     arg1 = ( Dali::KeyEvent * )jarg1;
31193     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31194     jresult = SWIG_csharp_string_callback( result->c_str() );
31195   }
31196
31197   return jresult;
31198 }
31199
31200
31201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31202   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31203   std::string *arg2 = 0 ;
31204
31205   arg1 = (Dali::KeyEvent *)jarg1;
31206   if (!jarg2) {
31207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31208     return ;
31209   }
31210   std::string arg2_str(jarg2);
31211   arg2 = &arg2_str;
31212   if (arg1) (arg1)->keyPressed = *arg2;
31213
31214   //argout typemap for const std::string&
31215
31216 }
31217
31218
31219 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31220   char * jresult ;
31221   if( NULL == jarg1 )
31222   {
31223     jresult = SWIG_csharp_string_callback( "" );
31224   }
31225   else
31226   {
31227     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31228     std::string *result = 0;
31229
31230     arg1 = ( Dali::KeyEvent * )jarg1;
31231     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31232     jresult = SWIG_csharp_string_callback( result->c_str() );
31233   }
31234   return jresult;
31235 }
31236
31237
31238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31239   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31240   int arg2 ;
31241
31242   arg1 = (Dali::KeyEvent *)jarg1;
31243   arg2 = (int)jarg2;
31244   if (arg1) (arg1)->keyCode = arg2;
31245 }
31246
31247
31248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31249   int jresult ;
31250   if( NULL == jarg1 )
31251   {
31252     jresult = -1;
31253   }
31254   else
31255   {
31256     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31257     int result;
31258
31259     arg1 = ( Dali::KeyEvent * )jarg1;
31260     result = (int)( ( arg1 )->keyCode );
31261     jresult = result;
31262   }
31263   return jresult;
31264 }
31265
31266
31267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31268   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31269   int arg2 ;
31270
31271   arg1 = (Dali::KeyEvent *)jarg1;
31272   arg2 = (int)jarg2;
31273   if (arg1) (arg1)->keyModifier = arg2;
31274 }
31275
31276
31277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31278   int jresult ;
31279   if( jarg1 == NULL )
31280   {
31281     jresult = -1;
31282   }
31283   else
31284   {
31285     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31286     int result;
31287
31288     arg1 = ( Dali::KeyEvent * )jarg1;
31289     result = (int)( ( arg1 )->keyModifier );
31290     jresult = result;
31291   }
31292   return jresult;
31293 }
31294
31295
31296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31297   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31298   unsigned long arg2 ;
31299
31300   arg1 = (Dali::KeyEvent *)jarg1;
31301   arg2 = (unsigned long)jarg2;
31302   if (arg1) (arg1)->time = arg2;
31303 }
31304
31305
31306 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31307   unsigned long jresult ;
31308   if( jarg1 == NULL )
31309   {
31310     jresult = 0;
31311   }
31312   else
31313   {
31314     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31315     unsigned long result;
31316
31317     arg1 = ( Dali::KeyEvent * )jarg1;
31318     result = (unsigned long)( ( arg1 )->time );
31319     jresult = (unsigned long)result;
31320   }
31321   return jresult;
31322 }
31323
31324
31325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31326   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31327   Dali::KeyEvent::State arg2 ;
31328
31329   arg1 = (Dali::KeyEvent *)jarg1;
31330   arg2 = (Dali::KeyEvent::State)jarg2;
31331   if (arg1) (arg1)->state = arg2;
31332 }
31333
31334
31335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31336   int jresult ;
31337   if( jarg1 == NULL )
31338   {
31339     jresult = -1;
31340   }
31341   else
31342   {
31343     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31344     Dali::KeyEvent::State result;
31345
31346     arg1 = ( Dali::KeyEvent * )jarg1;
31347     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31348     jresult = (int)result;
31349   }
31350   return jresult;
31351 }
31352
31353 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31354   char * jresult ;
31355   std::string result;
31356   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31357
31358   arg1 = (Dali::KeyEvent *)jarg1;
31359   if (!arg1) {
31360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31361     return 0;
31362   }
31363   {
31364     try {
31365       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31366     } catch (std::out_of_range& e) {
31367       {
31368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31369       };
31370     } catch (std::exception& e) {
31371       {
31372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31373       };
31374     } catch (Dali::DaliException e) {
31375       {
31376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31377       };
31378     } catch (...) {
31379       {
31380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31381       };
31382     }
31383
31384   }
31385
31386   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31387   return jresult;
31388 }
31389
31390
31391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31392   void * jresult ;
31393   Dali::LongPressGestureDetector *result = 0 ;
31394
31395   {
31396     try {
31397       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31398     } catch (std::out_of_range& e) {
31399       {
31400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31401       };
31402     } catch (std::exception& e) {
31403       {
31404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31405       };
31406     } catch (Dali::DaliException e) {
31407       {
31408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31409       };
31410     } catch (...) {
31411       {
31412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31413       };
31414     }
31415   }
31416
31417   jresult = (void *)result;
31418   return jresult;
31419 }
31420
31421
31422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31423   void * jresult ;
31424   Dali::LongPressGestureDetector result;
31425
31426   {
31427     try {
31428       result = Dali::LongPressGestureDetector::New();
31429     } catch (std::out_of_range& e) {
31430       {
31431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31432       };
31433     } catch (std::exception& e) {
31434       {
31435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31436       };
31437     } catch (Dali::DaliException e) {
31438       {
31439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31440       };
31441     } catch (...) {
31442       {
31443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31444       };
31445     }
31446   }
31447
31448   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31449   return jresult;
31450 }
31451
31452
31453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31454   void * jresult ;
31455   unsigned int arg1 ;
31456   Dali::LongPressGestureDetector result;
31457
31458   arg1 = (unsigned int)jarg1;
31459   {
31460     try {
31461       result = Dali::LongPressGestureDetector::New(arg1);
31462     } catch (std::out_of_range& e) {
31463       {
31464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31465       };
31466     } catch (std::exception& e) {
31467       {
31468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31469       };
31470     } catch (Dali::DaliException e) {
31471       {
31472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31473       };
31474     } catch (...) {
31475       {
31476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31477       };
31478     }
31479   }
31480
31481   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31482   return jresult;
31483 }
31484
31485
31486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31487   void * jresult ;
31488   unsigned int arg1 ;
31489   unsigned int arg2 ;
31490   Dali::LongPressGestureDetector result;
31491
31492   arg1 = (unsigned int)jarg1;
31493   arg2 = (unsigned int)jarg2;
31494   {
31495     try {
31496       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31497     } catch (std::out_of_range& e) {
31498       {
31499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31500       };
31501     } catch (std::exception& e) {
31502       {
31503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31504       };
31505     } catch (Dali::DaliException e) {
31506       {
31507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31508       };
31509     } catch (...) {
31510       {
31511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31512       };
31513     }
31514   }
31515
31516   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31517   return jresult;
31518 }
31519
31520
31521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31522   void * jresult ;
31523   Dali::BaseHandle arg1 ;
31524   Dali::BaseHandle *argp1 ;
31525   Dali::LongPressGestureDetector result;
31526
31527   argp1 = (Dali::BaseHandle *)jarg1;
31528   if (!argp1) {
31529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31530     return 0;
31531   }
31532   arg1 = *argp1;
31533   {
31534     try {
31535       result = Dali::LongPressGestureDetector::DownCast(arg1);
31536     } catch (std::out_of_range& e) {
31537       {
31538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31539       };
31540     } catch (std::exception& e) {
31541       {
31542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31543       };
31544     } catch (Dali::DaliException e) {
31545       {
31546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31547       };
31548     } catch (...) {
31549       {
31550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31551       };
31552     }
31553   }
31554
31555   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31556   return jresult;
31557 }
31558
31559
31560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31561   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31562
31563   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31564   {
31565     try {
31566       delete arg1;
31567     } catch (std::out_of_range& e) {
31568       {
31569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31570       };
31571     } catch (std::exception& e) {
31572       {
31573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31574       };
31575     } catch (Dali::DaliException e) {
31576       {
31577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31578       };
31579     } catch (...) {
31580       {
31581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31582       };
31583     }
31584   }
31585
31586 }
31587
31588
31589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31590   void * jresult ;
31591   Dali::LongPressGestureDetector *arg1 = 0 ;
31592   Dali::LongPressGestureDetector *result = 0 ;
31593
31594   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31595   if (!arg1) {
31596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31597     return 0;
31598   }
31599   {
31600     try {
31601       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31602     } catch (std::out_of_range& e) {
31603       {
31604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31605       };
31606     } catch (std::exception& e) {
31607       {
31608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31609       };
31610     } catch (Dali::DaliException e) {
31611       {
31612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31613       };
31614     } catch (...) {
31615       {
31616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31617       };
31618     }
31619   }
31620
31621   jresult = (void *)result;
31622   return jresult;
31623 }
31624
31625
31626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31627   void * jresult ;
31628   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31629   Dali::LongPressGestureDetector *arg2 = 0 ;
31630   Dali::LongPressGestureDetector *result = 0 ;
31631
31632   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31633   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31634   if (!arg2) {
31635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31636     return 0;
31637   }
31638   {
31639     try {
31640       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31641     } catch (std::out_of_range& e) {
31642       {
31643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31644       };
31645     } catch (std::exception& e) {
31646       {
31647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31648       };
31649     } catch (Dali::DaliException e) {
31650       {
31651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31652       };
31653     } catch (...) {
31654       {
31655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31656       };
31657     }
31658   }
31659
31660   jresult = (void *)result;
31661   return jresult;
31662 }
31663
31664
31665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31666   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31667   unsigned int arg2 ;
31668
31669   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31670   arg2 = (unsigned int)jarg2;
31671   {
31672     try {
31673       (arg1)->SetTouchesRequired(arg2);
31674     } catch (std::out_of_range& e) {
31675       {
31676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31677       };
31678     } catch (std::exception& e) {
31679       {
31680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31681       };
31682     } catch (Dali::DaliException e) {
31683       {
31684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31685       };
31686     } catch (...) {
31687       {
31688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31689       };
31690     }
31691   }
31692
31693 }
31694
31695
31696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31697   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31698   unsigned int arg2 ;
31699   unsigned int arg3 ;
31700
31701   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31702   arg2 = (unsigned int)jarg2;
31703   arg3 = (unsigned int)jarg3;
31704   {
31705     try {
31706       (arg1)->SetTouchesRequired(arg2,arg3);
31707     } catch (std::out_of_range& e) {
31708       {
31709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31710       };
31711     } catch (std::exception& e) {
31712       {
31713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31714       };
31715     } catch (Dali::DaliException e) {
31716       {
31717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31718       };
31719     } catch (...) {
31720       {
31721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31722       };
31723     }
31724   }
31725
31726 }
31727
31728
31729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31730   unsigned int jresult ;
31731   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31732   unsigned int result;
31733
31734   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31735   {
31736     try {
31737       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31738     } catch (std::out_of_range& e) {
31739       {
31740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31741       };
31742     } catch (std::exception& e) {
31743       {
31744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31745       };
31746     } catch (Dali::DaliException e) {
31747       {
31748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31749       };
31750     } catch (...) {
31751       {
31752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31753       };
31754     }
31755   }
31756
31757   jresult = result;
31758   return jresult;
31759 }
31760
31761
31762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31763   unsigned int jresult ;
31764   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31765   unsigned int result;
31766
31767   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31768   {
31769     try {
31770       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31771     } catch (std::out_of_range& e) {
31772       {
31773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31774       };
31775     } catch (std::exception& e) {
31776       {
31777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31778       };
31779     } catch (Dali::DaliException e) {
31780       {
31781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31782       };
31783     } catch (...) {
31784       {
31785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31786       };
31787     }
31788   }
31789
31790   jresult = result;
31791   return jresult;
31792 }
31793
31794
31795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31796   void * jresult ;
31797   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31798   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31799
31800   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31801   {
31802     try {
31803       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31804     } catch (std::out_of_range& e) {
31805       {
31806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31807       };
31808     } catch (std::exception& e) {
31809       {
31810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31811       };
31812     } catch (Dali::DaliException e) {
31813       {
31814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31815       };
31816     } catch (...) {
31817       {
31818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31819       };
31820     }
31821   }
31822
31823   jresult = (void *)result;
31824   return jresult;
31825 }
31826
31827
31828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31829   void * jresult ;
31830   Dali::Gesture::State arg1 ;
31831   Dali::LongPressGesture *result = 0 ;
31832
31833   arg1 = (Dali::Gesture::State)jarg1;
31834   {
31835     try {
31836       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31837     } catch (std::out_of_range& e) {
31838       {
31839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31840       };
31841     } catch (std::exception& e) {
31842       {
31843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31844       };
31845     } catch (Dali::DaliException e) {
31846       {
31847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31848       };
31849     } catch (...) {
31850       {
31851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31852       };
31853     }
31854   }
31855
31856   jresult = (void *)result;
31857   return jresult;
31858 }
31859
31860
31861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31862   void * jresult ;
31863   Dali::LongPressGesture *arg1 = 0 ;
31864   Dali::LongPressGesture *result = 0 ;
31865
31866   arg1 = (Dali::LongPressGesture *)jarg1;
31867   if (!arg1) {
31868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31869     return 0;
31870   }
31871   {
31872     try {
31873       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31874     } catch (std::out_of_range& e) {
31875       {
31876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31877       };
31878     } catch (std::exception& e) {
31879       {
31880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31881       };
31882     } catch (Dali::DaliException e) {
31883       {
31884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31885       };
31886     } catch (...) {
31887       {
31888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31889       };
31890     }
31891   }
31892
31893   jresult = (void *)result;
31894   return jresult;
31895 }
31896
31897
31898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31899   void * jresult ;
31900   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31901   Dali::LongPressGesture *arg2 = 0 ;
31902   Dali::LongPressGesture *result = 0 ;
31903
31904   arg1 = (Dali::LongPressGesture *)jarg1;
31905   arg2 = (Dali::LongPressGesture *)jarg2;
31906   if (!arg2) {
31907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31908     return 0;
31909   }
31910   {
31911     try {
31912       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31913     } catch (std::out_of_range& e) {
31914       {
31915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31916       };
31917     } catch (std::exception& e) {
31918       {
31919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31920       };
31921     } catch (Dali::DaliException e) {
31922       {
31923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31924       };
31925     } catch (...) {
31926       {
31927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31928       };
31929     }
31930   }
31931
31932   jresult = (void *)result;
31933   return jresult;
31934 }
31935
31936
31937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
31938   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31939
31940   arg1 = (Dali::LongPressGesture *)jarg1;
31941   {
31942     try {
31943       delete arg1;
31944     } catch (std::out_of_range& e) {
31945       {
31946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31947       };
31948     } catch (std::exception& e) {
31949       {
31950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31951       };
31952     } catch (Dali::DaliException e) {
31953       {
31954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31955       };
31956     } catch (...) {
31957       {
31958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31959       };
31960     }
31961   }
31962
31963 }
31964
31965
31966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
31967   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31968   unsigned int arg2 ;
31969
31970   arg1 = (Dali::LongPressGesture *)jarg1;
31971   arg2 = (unsigned int)jarg2;
31972   if (arg1) (arg1)->numberOfTouches = arg2;
31973 }
31974
31975
31976 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
31977   unsigned int jresult ;
31978   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31979   unsigned int result;
31980
31981   arg1 = (Dali::LongPressGesture *)jarg1;
31982   result = (unsigned int) ((arg1)->numberOfTouches);
31983   jresult = result;
31984   return jresult;
31985 }
31986
31987
31988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
31989   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31990   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31991
31992   arg1 = (Dali::LongPressGesture *)jarg1;
31993   arg2 = (Dali::Vector2 *)jarg2;
31994   if (arg1) (arg1)->screenPoint = *arg2;
31995 }
31996
31997
31998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
31999   void * jresult ;
32000   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32001   Dali::Vector2 *result = 0 ;
32002
32003   arg1 = (Dali::LongPressGesture *)jarg1;
32004   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32005   jresult = (void *)result;
32006   return jresult;
32007 }
32008
32009
32010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32011   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32012   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32013
32014   arg1 = (Dali::LongPressGesture *)jarg1;
32015   arg2 = (Dali::Vector2 *)jarg2;
32016   if (arg1) (arg1)->localPoint = *arg2;
32017 }
32018
32019
32020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32021   void * jresult ;
32022   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32023   Dali::Vector2 *result = 0 ;
32024
32025   arg1 = (Dali::LongPressGesture *)jarg1;
32026   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32027   jresult = (void *)result;
32028   return jresult;
32029 }
32030
32031
32032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32033   void * jresult ;
32034   Dali::WheelEvent *result = 0 ;
32035
32036   {
32037     try {
32038       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32039     } catch (std::out_of_range& e) {
32040       {
32041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32042       };
32043     } catch (std::exception& e) {
32044       {
32045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32046       };
32047     } catch (Dali::DaliException e) {
32048       {
32049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32050       };
32051     } catch (...) {
32052       {
32053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32054       };
32055     }
32056   }
32057
32058   jresult = (void *)result;
32059   return jresult;
32060 }
32061
32062
32063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32064   void * jresult ;
32065   Dali::WheelEvent::Type arg1 ;
32066   int arg2 ;
32067   unsigned int arg3 ;
32068   Dali::Vector2 arg4 ;
32069   int arg5 ;
32070   unsigned int arg6 ;
32071   Dali::Vector2 *argp4 ;
32072   Dali::WheelEvent *result = 0 ;
32073
32074   arg1 = (Dali::WheelEvent::Type)jarg1;
32075   arg2 = (int)jarg2;
32076   arg3 = (unsigned int)jarg3;
32077   argp4 = (Dali::Vector2 *)jarg4;
32078   if (!argp4) {
32079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32080     return 0;
32081   }
32082   arg4 = *argp4;
32083   arg5 = (int)jarg5;
32084   arg6 = (unsigned int)jarg6;
32085   {
32086     try {
32087       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32088     } catch (std::out_of_range& e) {
32089       {
32090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32091       };
32092     } catch (std::exception& e) {
32093       {
32094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32095       };
32096     } catch (Dali::DaliException e) {
32097       {
32098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32099       };
32100     } catch (...) {
32101       {
32102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32103       };
32104     }
32105   }
32106
32107   jresult = (void *)result;
32108   return jresult;
32109 }
32110
32111
32112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32113   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32114
32115   arg1 = (Dali::WheelEvent *)jarg1;
32116   {
32117     try {
32118       delete arg1;
32119     } catch (std::out_of_range& e) {
32120       {
32121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32122       };
32123     } catch (std::exception& e) {
32124       {
32125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32126       };
32127     } catch (Dali::DaliException e) {
32128       {
32129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32130       };
32131     } catch (...) {
32132       {
32133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32134       };
32135     }
32136   }
32137
32138 }
32139
32140
32141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32142   unsigned int jresult ;
32143   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32144   bool result;
32145
32146   arg1 = (Dali::WheelEvent *)jarg1;
32147   {
32148     try {
32149       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32150     } catch (std::out_of_range& e) {
32151       {
32152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32153       };
32154     } catch (std::exception& e) {
32155       {
32156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32157       };
32158     } catch (Dali::DaliException e) {
32159       {
32160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32161       };
32162     } catch (...) {
32163       {
32164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32165       };
32166     }
32167   }
32168
32169   jresult = result;
32170   return jresult;
32171 }
32172
32173
32174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32175   unsigned int jresult ;
32176   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32177   bool result;
32178
32179   arg1 = (Dali::WheelEvent *)jarg1;
32180   {
32181     try {
32182       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32183     } catch (std::out_of_range& e) {
32184       {
32185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32186       };
32187     } catch (std::exception& e) {
32188       {
32189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32190       };
32191     } catch (Dali::DaliException e) {
32192       {
32193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32194       };
32195     } catch (...) {
32196       {
32197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32198       };
32199     }
32200   }
32201
32202   jresult = result;
32203   return jresult;
32204 }
32205
32206
32207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32208   unsigned int jresult ;
32209   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32210   bool result;
32211
32212   arg1 = (Dali::WheelEvent *)jarg1;
32213   {
32214     try {
32215       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32216     } catch (std::out_of_range& e) {
32217       {
32218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32219       };
32220     } catch (std::exception& e) {
32221       {
32222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32223       };
32224     } catch (Dali::DaliException e) {
32225       {
32226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32227       };
32228     } catch (...) {
32229       {
32230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32231       };
32232     }
32233   }
32234
32235   jresult = result;
32236   return jresult;
32237 }
32238
32239
32240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32241   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32242   Dali::WheelEvent::Type arg2 ;
32243
32244   arg1 = (Dali::WheelEvent *)jarg1;
32245   arg2 = (Dali::WheelEvent::Type)jarg2;
32246   if (arg1) (arg1)->type = arg2;
32247 }
32248
32249
32250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32251   int jresult ;
32252   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32253   Dali::WheelEvent::Type result;
32254
32255   arg1 = (Dali::WheelEvent *)jarg1;
32256   result = (Dali::WheelEvent::Type) ((arg1)->type);
32257   jresult = (int)result;
32258   return jresult;
32259 }
32260
32261
32262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32263   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32264   int arg2 ;
32265
32266   arg1 = (Dali::WheelEvent *)jarg1;
32267   arg2 = (int)jarg2;
32268   if (arg1) (arg1)->direction = arg2;
32269 }
32270
32271
32272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32273   int jresult ;
32274   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32275   int result;
32276
32277   arg1 = (Dali::WheelEvent *)jarg1;
32278   result = (int) ((arg1)->direction);
32279   jresult = result;
32280   return jresult;
32281 }
32282
32283
32284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32285   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32286   unsigned int arg2 ;
32287
32288   arg1 = (Dali::WheelEvent *)jarg1;
32289   arg2 = (unsigned int)jarg2;
32290   if (arg1) (arg1)->modifiers = arg2;
32291 }
32292
32293
32294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32295   unsigned int jresult ;
32296   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32297   unsigned int result;
32298
32299   arg1 = (Dali::WheelEvent *)jarg1;
32300   result = (unsigned int) ((arg1)->modifiers);
32301   jresult = result;
32302   return jresult;
32303 }
32304
32305
32306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32307   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32308   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32309
32310   arg1 = (Dali::WheelEvent *)jarg1;
32311   arg2 = (Dali::Vector2 *)jarg2;
32312   if (arg1) (arg1)->point = *arg2;
32313 }
32314
32315
32316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32317   void * jresult ;
32318   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32319   Dali::Vector2 *result = 0 ;
32320
32321   arg1 = (Dali::WheelEvent *)jarg1;
32322   result = (Dali::Vector2 *)& ((arg1)->point);
32323   jresult = (void *)result;
32324   return jresult;
32325 }
32326
32327
32328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32329   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32330   int arg2 ;
32331
32332   arg1 = (Dali::WheelEvent *)jarg1;
32333   arg2 = (int)jarg2;
32334   if (arg1) (arg1)->z = arg2;
32335 }
32336
32337
32338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32339   int jresult ;
32340   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32341   int result;
32342
32343   arg1 = (Dali::WheelEvent *)jarg1;
32344   result = (int) ((arg1)->z);
32345   jresult = result;
32346   return jresult;
32347 }
32348
32349
32350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32351   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32352   unsigned int arg2 ;
32353
32354   arg1 = (Dali::WheelEvent *)jarg1;
32355   arg2 = (unsigned int)jarg2;
32356   if (arg1) (arg1)->timeStamp = arg2;
32357 }
32358
32359
32360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32361   unsigned int jresult ;
32362   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32363   unsigned int result;
32364
32365   arg1 = (Dali::WheelEvent *)jarg1;
32366   result = (unsigned int) ((arg1)->timeStamp);
32367   jresult = result;
32368   return jresult;
32369 }
32370
32371 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32372   char * jresult ;
32373   Dali::KeyEvent *arg1 = 0 ;
32374   std::string result;
32375
32376   arg1 = (Dali::KeyEvent *)jarg1;
32377   if (!arg1) {
32378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32379     return 0;
32380   }
32381   {
32382     try {
32383       result = arg1->GetDeviceName();
32384     } catch (std::out_of_range& e) {
32385       {
32386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32387       };
32388     } catch (std::exception& e) {
32389       {
32390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32391       };
32392     } catch (Dali::DaliException e) {
32393       {
32394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32395       };
32396     } catch (...) {
32397       {
32398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32399       };
32400     }
32401   }
32402
32403   jresult = SWIG_csharp_string_callback((&result)->c_str());
32404   return jresult;
32405 }
32406
32407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32408   int jresult ;
32409   Dali::KeyEvent *arg1 = 0 ;
32410   Dali::Device::Class::Type result;
32411
32412   arg1 = (Dali::KeyEvent *)jarg1;
32413   if (!arg1) {
32414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32415     return 0;
32416   }
32417   {
32418     try {
32419       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32420     } catch (std::out_of_range& e) {
32421       {
32422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32423       };
32424     } catch (std::exception& e) {
32425       {
32426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32427       };
32428     } catch (Dali::DaliException e) {
32429       {
32430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32431       };
32432     } catch (...) {
32433       {
32434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32435       };
32436     }
32437   }
32438
32439   jresult = (int)result;
32440   return jresult;
32441 }
32442
32443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32444   int jresult ;
32445   Dali::KeyEvent *arg1 = 0 ;
32446   Dali::Device::Subclass::Type result;
32447
32448   arg1 = (Dali::KeyEvent *)jarg1;
32449   if (!arg1) {
32450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32451     return 0;
32452   }
32453   {
32454     try {
32455       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32456     } catch (std::out_of_range& e) {
32457       {
32458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32459       };
32460     } catch (std::exception& e) {
32461       {
32462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32463       };
32464     } catch (Dali::DaliException e) {
32465       {
32466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32467       };
32468     } catch (...) {
32469       {
32470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32471       };
32472     }
32473   }
32474
32475   jresult = (int)result;
32476   return jresult;
32477 }
32478
32479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32480   Dali::Actor arg1 ;
32481   Dali::Actor *argp1 ;
32482
32483   argp1 = (Dali::Actor *)jarg1;
32484   if (!argp1) {
32485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32486     return ;
32487   }
32488   arg1 = *argp1;
32489   {
32490     try {
32491       arg1.Raise();
32492     } catch (std::out_of_range& e) {
32493       {
32494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32495       };
32496     } catch (std::exception& e) {
32497       {
32498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32499       };
32500     } catch (Dali::DaliException e) {
32501       {
32502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32503       };
32504     } catch (...) {
32505       {
32506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32507       };
32508     }
32509   }
32510
32511 }
32512
32513
32514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32515   Dali::Actor arg1 ;
32516   Dali::Actor *argp1 ;
32517
32518   argp1 = (Dali::Actor *)jarg1;
32519   if (!argp1) {
32520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32521     return ;
32522   }
32523   arg1 = *argp1;
32524   {
32525     try {
32526       arg1.Lower();
32527     } catch (std::out_of_range& e) {
32528       {
32529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32530       };
32531     } catch (std::exception& e) {
32532       {
32533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32534       };
32535     } catch (Dali::DaliException e) {
32536       {
32537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32538       };
32539     } catch (...) {
32540       {
32541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32542       };
32543     }
32544   }
32545
32546 }
32547
32548
32549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32550   Dali::Actor arg1 ;
32551   Dali::Actor *argp1 ;
32552
32553   argp1 = (Dali::Actor *)jarg1;
32554   if (!argp1) {
32555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32556     return ;
32557   }
32558   arg1 = *argp1;
32559   {
32560     try {
32561       arg1.RaiseToTop();
32562     } catch (std::out_of_range& e) {
32563       {
32564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32565       };
32566     } catch (std::exception& e) {
32567       {
32568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32569       };
32570     } catch (Dali::DaliException e) {
32571       {
32572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32573       };
32574     } catch (...) {
32575       {
32576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32577       };
32578     }
32579   }
32580
32581 }
32582
32583
32584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32585   Dali::Actor arg1 ;
32586   Dali::Actor *argp1 ;
32587
32588   argp1 = (Dali::Actor *)jarg1;
32589   if (!argp1) {
32590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32591     return ;
32592   }
32593   arg1 = *argp1;
32594   {
32595     try {
32596       arg1.LowerToBottom();
32597     } catch (std::out_of_range& e) {
32598       {
32599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32600       };
32601     } catch (std::exception& e) {
32602       {
32603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32604       };
32605     } catch (Dali::DaliException e) {
32606       {
32607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32608       };
32609     } catch (...) {
32610       {
32611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32612       };
32613     }
32614   }
32615
32616 }
32617
32618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32619   Dali::Actor arg1 ;
32620   Dali::Actor arg2 ;
32621   Dali::Actor *argp1 ;
32622   Dali::Actor *argp2 ;
32623
32624   argp1 = (Dali::Actor *)jarg1;
32625   if (!argp1) {
32626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32627     return ;
32628   }
32629   arg1 = *argp1;
32630   argp2 = (Dali::Actor *)jarg2;
32631   if (!argp2) {
32632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32633     return ;
32634   }
32635   arg2 = *argp2;
32636   {
32637     try {
32638       arg1.RaiseAbove(arg2);
32639     } catch (std::out_of_range& e) {
32640       {
32641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32642       };
32643     } catch (std::exception& e) {
32644       {
32645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32646       };
32647     } catch (Dali::DaliException e) {
32648       {
32649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32650       };
32651     } catch (...) {
32652       {
32653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32654       };
32655     }
32656   }
32657
32658 }
32659
32660
32661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32662   Dali::Actor arg1 ;
32663   Dali::Actor arg2 ;
32664   Dali::Actor *argp1 ;
32665   Dali::Actor *argp2 ;
32666
32667   argp1 = (Dali::Actor *)jarg1;
32668   if (!argp1) {
32669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32670     return ;
32671   }
32672   arg1 = *argp1;
32673   argp2 = (Dali::Actor *)jarg2;
32674   if (!argp2) {
32675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32676     return ;
32677   }
32678   arg2 = *argp2;
32679   {
32680     try {
32681       arg1.LowerBelow(arg2);
32682     } catch (std::out_of_range& e) {
32683       {
32684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32685       };
32686     } catch (std::exception& e) {
32687       {
32688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32689       };
32690     } catch (Dali::DaliException e) {
32691       {
32692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32693       };
32694     } catch (...) {
32695       {
32696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32697       };
32698     }
32699   }
32700
32701 }
32702
32703
32704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32705   void * jresult ;
32706   Dali::Actor arg1 ;
32707   Dali::Actor *argp1 ;
32708   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32709
32710   argp1 = (Dali::Actor *)jarg1;
32711   if (!argp1) {
32712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32713     return 0;
32714   }
32715   arg1 = *argp1;
32716   {
32717     try {
32718       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32719     } catch (std::out_of_range& e) {
32720       {
32721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32722       };
32723     } catch (std::exception& e) {
32724       {
32725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32726       };
32727     } catch (Dali::DaliException e) {
32728       {
32729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32730       };
32731     } catch (...) {
32732       {
32733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32734       };
32735     }
32736   }
32737
32738   jresult = (void *)result;
32739   return jresult;
32740 }
32741
32742
32743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32744   void * jresult ;
32745   Dali::Actor *arg1 ;
32746   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32747
32748   arg1 = (Dali::Actor *)jarg1;
32749   {
32750     try {
32751       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32752     } catch (std::out_of_range& e) {
32753       {
32754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32755       };
32756     } catch (std::exception& e) {
32757       {
32758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32759       };
32760     } catch (Dali::DaliException e) {
32761       {
32762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32763       };
32764     } catch (...) {
32765       {
32766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32767       };
32768     }
32769   }
32770
32771   jresult = (void *)result;
32772   return jresult;
32773 }
32774
32775
32776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32777   int jresult ;
32778   int result;
32779
32780   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32781   jresult = (int)result;
32782   return jresult;
32783 }
32784
32785
32786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32787   int jresult ;
32788   int result;
32789
32790   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32791   jresult = (int)result;
32792   return jresult;
32793 }
32794
32795
32796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32797   int jresult ;
32798   int result;
32799
32800   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32801   jresult = (int)result;
32802   return jresult;
32803 }
32804
32805
32806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32807   int jresult ;
32808   int result;
32809
32810   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32811   jresult = (int)result;
32812   return jresult;
32813 }
32814
32815
32816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32817   int jresult ;
32818   int result;
32819
32820   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32821   jresult = (int)result;
32822   return jresult;
32823 }
32824
32825
32826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32827   int jresult ;
32828   int result;
32829
32830   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32831   jresult = (int)result;
32832   return jresult;
32833 }
32834
32835
32836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32837   int jresult ;
32838   int result;
32839
32840   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32841   jresult = (int)result;
32842   return jresult;
32843 }
32844
32845
32846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32847   int jresult ;
32848   int result;
32849
32850   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32851   jresult = (int)result;
32852   return jresult;
32853 }
32854
32855
32856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32857   int jresult ;
32858   int result;
32859
32860   result = (int)Dali::Actor::Property::SIZE;
32861   jresult = (int)result;
32862   return jresult;
32863 }
32864
32865
32866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32867   int jresult ;
32868   int result;
32869
32870   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32871   jresult = (int)result;
32872   return jresult;
32873 }
32874
32875
32876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32877   int jresult ;
32878   int result;
32879
32880   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32881   jresult = (int)result;
32882   return jresult;
32883 }
32884
32885
32886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32887   int jresult ;
32888   int result;
32889
32890   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32891   jresult = (int)result;
32892   return jresult;
32893 }
32894
32895
32896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32897   int jresult ;
32898   int result;
32899
32900   result = (int)Dali::Actor::Property::POSITION;
32901   jresult = (int)result;
32902   return jresult;
32903 }
32904
32905
32906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32907   int jresult ;
32908   int result;
32909
32910   result = (int)Dali::Actor::Property::POSITION_X;
32911   jresult = (int)result;
32912   return jresult;
32913 }
32914
32915
32916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32917   int jresult ;
32918   int result;
32919
32920   result = (int)Dali::Actor::Property::POSITION_Y;
32921   jresult = (int)result;
32922   return jresult;
32923 }
32924
32925
32926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32927   int jresult ;
32928   int result;
32929
32930   result = (int)Dali::Actor::Property::POSITION_Z;
32931   jresult = (int)result;
32932   return jresult;
32933 }
32934
32935
32936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
32937   int jresult ;
32938   int result;
32939
32940   result = (int)Dali::Actor::Property::WORLD_POSITION;
32941   jresult = (int)result;
32942   return jresult;
32943 }
32944
32945
32946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
32947   int jresult ;
32948   int result;
32949
32950   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
32951   jresult = (int)result;
32952   return jresult;
32953 }
32954
32955
32956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
32957   int jresult ;
32958   int result;
32959
32960   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
32961   jresult = (int)result;
32962   return jresult;
32963 }
32964
32965
32966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
32967   int jresult ;
32968   int result;
32969
32970   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
32971   jresult = (int)result;
32972   return jresult;
32973 }
32974
32975
32976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
32977   int jresult ;
32978   int result;
32979
32980   result = (int)Dali::Actor::Property::ORIENTATION;
32981   jresult = (int)result;
32982   return jresult;
32983 }
32984
32985
32986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
32987   int jresult ;
32988   int result;
32989
32990   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
32991   jresult = (int)result;
32992   return jresult;
32993 }
32994
32995
32996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
32997   int jresult ;
32998   int result;
32999
33000   result = (int)Dali::Actor::Property::SCALE;
33001   jresult = (int)result;
33002   return jresult;
33003 }
33004
33005
33006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33007   int jresult ;
33008   int result;
33009
33010   result = (int)Dali::Actor::Property::SCALE_X;
33011   jresult = (int)result;
33012   return jresult;
33013 }
33014
33015
33016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33017   int jresult ;
33018   int result;
33019
33020   result = (int)Dali::Actor::Property::SCALE_Y;
33021   jresult = (int)result;
33022   return jresult;
33023 }
33024
33025
33026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33027   int jresult ;
33028   int result;
33029
33030   result = (int)Dali::Actor::Property::SCALE_Z;
33031   jresult = (int)result;
33032   return jresult;
33033 }
33034
33035
33036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33037   int jresult ;
33038   int result;
33039
33040   result = (int)Dali::Actor::Property::WORLD_SCALE;
33041   jresult = (int)result;
33042   return jresult;
33043 }
33044
33045
33046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33047   int jresult ;
33048   int result;
33049
33050   result = (int)Dali::Actor::Property::VISIBLE;
33051   jresult = (int)result;
33052   return jresult;
33053 }
33054
33055
33056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33057   int jresult ;
33058   int result;
33059
33060   result = (int)Dali::Actor::Property::COLOR;
33061   jresult = (int)result;
33062   return jresult;
33063 }
33064
33065
33066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33067   int jresult ;
33068   int result;
33069
33070   result = (int)Dali::Actor::Property::COLOR_RED;
33071   jresult = (int)result;
33072   return jresult;
33073 }
33074
33075
33076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33077   int jresult ;
33078   int result;
33079
33080   result = (int)Dali::Actor::Property::COLOR_GREEN;
33081   jresult = (int)result;
33082   return jresult;
33083 }
33084
33085
33086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33087   int jresult ;
33088   int result;
33089
33090   result = (int)Dali::Actor::Property::COLOR_BLUE;
33091   jresult = (int)result;
33092   return jresult;
33093 }
33094
33095
33096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33097   int jresult ;
33098   int result;
33099
33100   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33101   jresult = (int)result;
33102   return jresult;
33103 }
33104
33105
33106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33107   int jresult ;
33108   int result;
33109
33110   result = (int)Dali::Actor::Property::WORLD_COLOR;
33111   jresult = (int)result;
33112   return jresult;
33113 }
33114
33115
33116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33117   int jresult ;
33118   int result;
33119
33120   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33121   jresult = (int)result;
33122   return jresult;
33123 }
33124
33125
33126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33127   int jresult ;
33128   int result;
33129
33130   result = (int)Dali::Actor::Property::NAME;
33131   jresult = (int)result;
33132   return jresult;
33133 }
33134
33135
33136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33137   int jresult ;
33138   int result;
33139
33140   result = (int)Dali::Actor::Property::SENSITIVE;
33141   jresult = (int)result;
33142   return jresult;
33143 }
33144
33145
33146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33147   int jresult ;
33148   int result;
33149
33150   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33151   jresult = (int)result;
33152   return jresult;
33153 }
33154
33155
33156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33157   int jresult ;
33158   int result;
33159
33160   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33161   jresult = (int)result;
33162   return jresult;
33163 }
33164
33165
33166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33167   int jresult ;
33168   int result;
33169
33170   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33171   jresult = (int)result;
33172   return jresult;
33173 }
33174
33175
33176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33177   int jresult ;
33178   int result;
33179
33180   result = (int)Dali::Actor::Property::COLOR_MODE;
33181   jresult = (int)result;
33182   return jresult;
33183 }
33184
33185
33186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33187   int jresult ;
33188   int result;
33189
33190   result = (int)Dali::Actor::Property::DRAW_MODE;
33191   jresult = (int)result;
33192   return jresult;
33193 }
33194
33195
33196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33197   int jresult ;
33198   int result;
33199
33200   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33201   jresult = (int)result;
33202   return jresult;
33203 }
33204
33205
33206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33207   int jresult ;
33208   int result;
33209
33210   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33211   jresult = (int)result;
33212   return jresult;
33213 }
33214
33215
33216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33217   int jresult ;
33218   int result;
33219
33220   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33221   jresult = (int)result;
33222   return jresult;
33223 }
33224
33225
33226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33227   int jresult ;
33228   int result;
33229
33230   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33231   jresult = (int)result;
33232   return jresult;
33233 }
33234
33235
33236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33237   int jresult ;
33238   int result;
33239
33240   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33241   jresult = (int)result;
33242   return jresult;
33243 }
33244
33245
33246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33247   int jresult ;
33248   int result;
33249
33250   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33251   jresult = (int)result;
33252   return jresult;
33253 }
33254
33255
33256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33257   int jresult ;
33258   int result;
33259
33260   result = (int)Dali::Actor::Property::PADDING;
33261   jresult = (int)result;
33262   return jresult;
33263 }
33264
33265
33266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33267   int jresult ;
33268   int result;
33269
33270   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33271   jresult = (int)result;
33272   return jresult;
33273 }
33274
33275
33276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33277   int jresult ;
33278   int result;
33279
33280   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33281   jresult = (int)result;
33282   return jresult;
33283 }
33284
33285
33286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33287   int jresult ;
33288   int result;
33289
33290   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33291   jresult = (int)result;
33292   return jresult;
33293 }
33294
33295
33296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33297   int jresult ;
33298   int result;
33299
33300   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33301   jresult = (int)result;
33302   return jresult;
33303 }
33304
33305 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
33306
33307   return Dali::Actor::Property::OPACITY;
33308 }
33309
33310 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
33311
33312   return Dali::Actor::Property::SCREEN_POSITION;
33313 }
33314
33315 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
33316
33317   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
33318 }
33319
33320 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
33321   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
33322 }
33323
33324 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
33325   return Dali::Actor::Property::LAYOUT_DIRECTION;
33326 }
33327
33328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33329   void * jresult ;
33330   Dali::Actor::Property *result = 0 ;
33331
33332   {
33333     try {
33334       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33335     } catch (std::out_of_range& e) {
33336       {
33337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33338       };
33339     } catch (std::exception& e) {
33340       {
33341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33342       };
33343     } catch (Dali::DaliException e) {
33344       {
33345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33346       };
33347     } catch (...) {
33348       {
33349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33350       };
33351     }
33352   }
33353
33354   jresult = (void *)result;
33355   return jresult;
33356 }
33357
33358
33359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33360   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33361
33362   arg1 = (Dali::Actor::Property *)jarg1;
33363   {
33364     try {
33365       delete arg1;
33366     } catch (std::out_of_range& e) {
33367       {
33368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33369       };
33370     } catch (std::exception& e) {
33371       {
33372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33373       };
33374     } catch (Dali::DaliException e) {
33375       {
33376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33377       };
33378     } catch (...) {
33379       {
33380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33381       };
33382     }
33383   }
33384
33385 }
33386
33387
33388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33389   void * jresult ;
33390   Dali::Actor *result = 0 ;
33391
33392   {
33393     try {
33394       result = (Dali::Actor *)new Dali::Actor();
33395     } catch (std::out_of_range& e) {
33396       {
33397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33398       };
33399     } catch (std::exception& e) {
33400       {
33401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33402       };
33403     } catch (Dali::DaliException e) {
33404       {
33405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33406       };
33407     } catch (...) {
33408       {
33409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33410       };
33411     }
33412   }
33413
33414   jresult = (void *)result;
33415   return jresult;
33416 }
33417
33418
33419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33420   void * jresult ;
33421   Dali::Actor result;
33422
33423   {
33424     try {
33425       result = Dali::Actor::New();
33426     } catch (std::out_of_range& e) {
33427       {
33428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33429       };
33430     } catch (std::exception& e) {
33431       {
33432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33433       };
33434     } catch (Dali::DaliException e) {
33435       {
33436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33437       };
33438     } catch (...) {
33439       {
33440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33441       };
33442     }
33443   }
33444
33445   jresult = new Dali::Actor((const Dali::Actor &)result);
33446   return jresult;
33447 }
33448
33449
33450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33451   void * jresult ;
33452   Dali::BaseHandle arg1 ;
33453   Dali::BaseHandle *argp1 ;
33454   Dali::Actor result;
33455
33456   argp1 = (Dali::BaseHandle *)jarg1;
33457   if (!argp1) {
33458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33459     return 0;
33460   }
33461   arg1 = *argp1;
33462   {
33463     try {
33464       result = Dali::Actor::DownCast(arg1);
33465     } catch (std::out_of_range& e) {
33466       {
33467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33468       };
33469     } catch (std::exception& e) {
33470       {
33471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33472       };
33473     } catch (Dali::DaliException e) {
33474       {
33475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33476       };
33477     } catch (...) {
33478       {
33479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33480       };
33481     }
33482   }
33483
33484   jresult = new Dali::Actor((const Dali::Actor &)result);
33485   return jresult;
33486 }
33487
33488
33489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33490   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33491
33492   arg1 = (Dali::Actor *)jarg1;
33493   {
33494     try {
33495       delete arg1;
33496     } catch (std::out_of_range& e) {
33497       {
33498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33499       };
33500     } catch (std::exception& e) {
33501       {
33502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33503       };
33504     } catch (Dali::DaliException e) {
33505       {
33506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33507       };
33508     } catch (...) {
33509       {
33510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33511       };
33512     }
33513   }
33514
33515 }
33516
33517
33518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33519   void * jresult ;
33520   Dali::Actor *arg1 = 0 ;
33521   Dali::Actor *result = 0 ;
33522
33523   arg1 = (Dali::Actor *)jarg1;
33524   if (!arg1) {
33525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33526     return 0;
33527   }
33528   {
33529     try {
33530       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33531     } catch (std::out_of_range& e) {
33532       {
33533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33534       };
33535     } catch (std::exception& e) {
33536       {
33537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33538       };
33539     } catch (Dali::DaliException e) {
33540       {
33541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33542       };
33543     } catch (...) {
33544       {
33545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33546       };
33547     }
33548   }
33549
33550   jresult = (void *)result;
33551   return jresult;
33552 }
33553
33554
33555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33556   void * jresult ;
33557   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33558   Dali::Actor *arg2 = 0 ;
33559   Dali::Actor *result = 0 ;
33560
33561   arg1 = (Dali::Actor *)jarg1;
33562   arg2 = (Dali::Actor *)jarg2;
33563   if (!arg2) {
33564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33565     return 0;
33566   }
33567   {
33568     try {
33569       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33570     } catch (std::out_of_range& e) {
33571       {
33572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33573       };
33574     } catch (std::exception& e) {
33575       {
33576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33577       };
33578     } catch (Dali::DaliException e) {
33579       {
33580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33581       };
33582     } catch (...) {
33583       {
33584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33585       };
33586     }
33587   }
33588
33589   jresult = (void *)result;
33590   return jresult;
33591 }
33592
33593
33594 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33595   char * jresult ;
33596   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33597   std::string *result = 0 ;
33598
33599   arg1 = (Dali::Actor *)jarg1;
33600   {
33601     try {
33602       std::string name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
33603       result = (std::string *) &name;
33604     } catch (std::out_of_range& e) {
33605       {
33606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33607       };
33608     } catch (std::exception& e) {
33609       {
33610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33611       };
33612     } catch (Dali::DaliException e) {
33613       {
33614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33615       };
33616     } catch (...) {
33617       {
33618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33619       };
33620     }
33621   }
33622
33623   jresult = SWIG_csharp_string_callback(result->c_str());
33624   return jresult;
33625 }
33626
33627
33628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33629   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33630   std::string *arg2 = 0 ;
33631
33632   arg1 = (Dali::Actor *)jarg1;
33633   if (!jarg2) {
33634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33635     return ;
33636   }
33637   std::string arg2_str(jarg2);
33638   arg2 = &arg2_str;
33639   {
33640     try {
33641       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
33642     } catch (std::out_of_range& e) {
33643       {
33644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33645       };
33646     } catch (std::exception& e) {
33647       {
33648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33649       };
33650     } catch (Dali::DaliException e) {
33651       {
33652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33653       };
33654     } catch (...) {
33655       {
33656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33657       };
33658     }
33659   }
33660
33661
33662   //argout typemap for const std::string&
33663
33664 }
33665
33666
33667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33668   unsigned int jresult ;
33669   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33670   unsigned int result;
33671
33672   arg1 = (Dali::Actor *)jarg1;
33673
33674   if(!arg1) {
33675     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33676     return -1;
33677   }
33678
33679   {
33680     try {
33681       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
33682     } catch (std::out_of_range& e) {
33683       {
33684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33685       };
33686     } catch (std::exception& e) {
33687       {
33688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33689       };
33690     } catch (Dali::DaliException e) {
33691       {
33692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33693       };
33694     } catch (...) {
33695       {
33696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33697       };
33698     }
33699   }
33700
33701   jresult = result;
33702   return jresult;
33703 }
33704
33705
33706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33707   unsigned int jresult ;
33708   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33709   bool result;
33710
33711   arg1 = (Dali::Actor *)jarg1;
33712   {
33713     try {
33714       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
33715     } catch (std::out_of_range& e) {
33716       {
33717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33718       };
33719     } catch (std::exception& e) {
33720       {
33721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33722       };
33723     } catch (Dali::DaliException e) {
33724       {
33725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33726       };
33727     } catch (...) {
33728       {
33729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33730       };
33731     }
33732   }
33733
33734   jresult = result;
33735   return jresult;
33736 }
33737
33738
33739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33740   unsigned int jresult ;
33741   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33742   bool result;
33743
33744   arg1 = (Dali::Actor *)jarg1;
33745   {
33746     try {
33747       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
33748     } catch (std::out_of_range& e) {
33749       {
33750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33751       };
33752     } catch (std::exception& e) {
33753       {
33754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33755       };
33756     } catch (Dali::DaliException e) {
33757       {
33758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33759       };
33760     } catch (...) {
33761       {
33762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33763       };
33764     }
33765   }
33766
33767   jresult = result;
33768   return jresult;
33769 }
33770
33771
33772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33773   unsigned int jresult ;
33774   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33775   bool result;
33776
33777   arg1 = (Dali::Actor *)jarg1;
33778   {
33779     try {
33780       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
33781     } catch (std::out_of_range& e) {
33782       {
33783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33784       };
33785     } catch (std::exception& e) {
33786       {
33787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33788       };
33789     } catch (Dali::DaliException e) {
33790       {
33791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33792       };
33793     } catch (...) {
33794       {
33795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33796       };
33797     }
33798   }
33799
33800   jresult = result;
33801   return jresult;
33802 }
33803
33804
33805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33806   void * jresult ;
33807   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33808   Dali::Layer result;
33809
33810   arg1 = (Dali::Actor *)jarg1;
33811   {
33812     try {
33813       result = (arg1)->GetLayer();
33814     } catch (std::out_of_range& e) {
33815       {
33816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33817       };
33818     } catch (std::exception& e) {
33819       {
33820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33821       };
33822     } catch (Dali::DaliException e) {
33823       {
33824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33825       };
33826     } catch (...) {
33827       {
33828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33829       };
33830     }
33831   }
33832
33833   jresult = new Dali::Layer((const Dali::Layer &)result);
33834   return jresult;
33835 }
33836
33837
33838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33839   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33840   Dali::Actor arg2 ;
33841   Dali::Actor *argp2 ;
33842
33843   arg1 = (Dali::Actor *)jarg1;
33844   argp2 = (Dali::Actor *)jarg2;
33845   if (!argp2) {
33846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33847     return ;
33848   }
33849   arg2 = *argp2;
33850   {
33851     try {
33852       (arg1)->Add(arg2);
33853     } catch (std::out_of_range& e) {
33854       {
33855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33856       };
33857     } catch (std::exception& e) {
33858       {
33859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33860       };
33861     } catch (Dali::DaliException e) {
33862       {
33863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33864       };
33865     } catch (...) {
33866       {
33867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33868       };
33869     }
33870   }
33871
33872 }
33873
33874
33875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33876   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33877   Dali::Actor arg2 ;
33878   Dali::Actor *argp2 ;
33879
33880   arg1 = (Dali::Actor *)jarg1;
33881   argp2 = (Dali::Actor *)jarg2;
33882   if (!argp2) {
33883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33884     return ;
33885   }
33886   arg2 = *argp2;
33887   {
33888     try {
33889       (arg1)->Remove(arg2);
33890     } catch (std::out_of_range& e) {
33891       {
33892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33893       };
33894     } catch (std::exception& e) {
33895       {
33896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33897       };
33898     } catch (Dali::DaliException e) {
33899       {
33900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33901       };
33902     } catch (...) {
33903       {
33904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33905       };
33906     }
33907   }
33908
33909 }
33910
33911
33912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33913   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33914
33915   arg1 = (Dali::Actor *)jarg1;
33916   {
33917     try {
33918       (arg1)->Unparent();
33919     } catch (std::out_of_range& e) {
33920       {
33921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33922       };
33923     } catch (std::exception& e) {
33924       {
33925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33926       };
33927     } catch (Dali::DaliException e) {
33928       {
33929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33930       };
33931     } catch (...) {
33932       {
33933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33934       };
33935     }
33936   }
33937
33938 }
33939
33940
33941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33942   unsigned int jresult ;
33943   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33944   unsigned int result;
33945
33946   arg1 = (Dali::Actor *)jarg1;
33947   {
33948     try {
33949       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33950     } catch (std::out_of_range& e) {
33951       {
33952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33953       };
33954     } catch (std::exception& e) {
33955       {
33956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33957       };
33958     } catch (Dali::DaliException e) {
33959       {
33960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33961       };
33962     } catch (...) {
33963       {
33964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33965       };
33966     }
33967   }
33968
33969   jresult = result;
33970   return jresult;
33971 }
33972
33973
33974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
33975   void * jresult ;
33976   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33977   unsigned int arg2 ;
33978   Dali::Actor result;
33979
33980   arg1 = (Dali::Actor *)jarg1;
33981   arg2 = (unsigned int)jarg2;
33982   {
33983     try {
33984       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
33985     } catch (std::out_of_range& e) {
33986       {
33987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33988       };
33989     } catch (std::exception& e) {
33990       {
33991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33992       };
33993     } catch (Dali::DaliException e) {
33994       {
33995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33996       };
33997     } catch (...) {
33998       {
33999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34000       };
34001     }
34002   }
34003
34004   jresult = new Dali::Actor((const Dali::Actor &)result);
34005   return jresult;
34006 }
34007
34008
34009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34010   void * jresult ;
34011   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34012   std::string *arg2 = 0 ;
34013   Dali::Actor result;
34014
34015   arg1 = (Dali::Actor *)jarg1;
34016   if (!jarg2) {
34017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34018     return 0;
34019   }
34020   std::string arg2_str(jarg2);
34021   arg2 = &arg2_str;
34022   {
34023     try {
34024       result = (arg1)->FindChildByName((std::string const &)*arg2);
34025     } catch (std::out_of_range& e) {
34026       {
34027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34028       };
34029     } catch (std::exception& e) {
34030       {
34031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34032       };
34033     } catch (Dali::DaliException e) {
34034       {
34035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34036       };
34037     } catch (...) {
34038       {
34039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34040       };
34041     }
34042   }
34043
34044   jresult = new Dali::Actor((const Dali::Actor &)result);
34045
34046   //argout typemap for const std::string&
34047
34048   return jresult;
34049 }
34050
34051
34052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34053   void * jresult ;
34054   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34055   unsigned int arg2 ;
34056   Dali::Actor result;
34057
34058   arg1 = (Dali::Actor *)jarg1;
34059   arg2 = (unsigned int)jarg2;
34060   {
34061     try {
34062       result = (arg1)->FindChildById(arg2);
34063     } catch (std::out_of_range& e) {
34064       {
34065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34066       };
34067     } catch (std::exception& e) {
34068       {
34069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34070       };
34071     } catch (Dali::DaliException e) {
34072       {
34073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34074       };
34075     } catch (...) {
34076       {
34077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34078       };
34079     }
34080   }
34081
34082   jresult = new Dali::Actor((const Dali::Actor &)result);
34083   return jresult;
34084 }
34085
34086
34087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34088   void * jresult ;
34089   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34090   Dali::Actor result;
34091
34092   arg1 = (Dali::Actor *)jarg1;
34093   {
34094     try {
34095       result = ((Dali::Actor const *)arg1)->GetParent();
34096     } catch (std::out_of_range& e) {
34097       {
34098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34099       };
34100     } catch (std::exception& e) {
34101       {
34102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34103       };
34104     } catch (Dali::DaliException e) {
34105       {
34106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34107       };
34108     } catch (...) {
34109       {
34110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34111       };
34112     }
34113   }
34114
34115   jresult = new Dali::Actor((const Dali::Actor &)result);
34116   return jresult;
34117 }
34118
34119
34120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34121   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34122   Dali::Vector3 *arg2 = 0 ;
34123
34124   arg1 = (Dali::Actor *)jarg1;
34125   arg2 = (Dali::Vector3 *)jarg2;
34126   if (!arg2) {
34127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34128     return ;
34129   }
34130   {
34131     try {
34132       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
34133     } catch (std::out_of_range& e) {
34134       {
34135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34136       };
34137     } catch (std::exception& e) {
34138       {
34139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34140       };
34141     } catch (Dali::DaliException e) {
34142       {
34143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34144       };
34145     } catch (...) {
34146       {
34147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34148       };
34149     }
34150   }
34151
34152 }
34153
34154
34155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34156   void * jresult ;
34157   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34158   Dali::Vector3 result;
34159
34160   arg1 = (Dali::Actor *)jarg1;
34161   {
34162     try {
34163       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
34164     } catch (std::out_of_range& e) {
34165       {
34166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34167       };
34168     } catch (std::exception& e) {
34169       {
34170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34171       };
34172     } catch (Dali::DaliException e) {
34173       {
34174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34175       };
34176     } catch (...) {
34177       {
34178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34179       };
34180     }
34181   }
34182
34183   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34184   return jresult;
34185 }
34186
34187
34188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34189   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34190   Dali::Vector3 *arg2 = 0 ;
34191
34192   arg1 = (Dali::Actor *)jarg1;
34193   arg2 = (Dali::Vector3 *)jarg2;
34194   if (!arg2) {
34195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34196     return ;
34197   }
34198   {
34199     try {
34200       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
34201     } catch (std::out_of_range& e) {
34202       {
34203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34204       };
34205     } catch (std::exception& e) {
34206       {
34207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34208       };
34209     } catch (Dali::DaliException e) {
34210       {
34211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34212       };
34213     } catch (...) {
34214       {
34215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34216       };
34217     }
34218   }
34219
34220 }
34221
34222
34223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34224   void * jresult ;
34225   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34226   Dali::Vector3 result;
34227
34228   arg1 = (Dali::Actor *)jarg1;
34229   {
34230     try {
34231       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
34232     } catch (std::out_of_range& e) {
34233       {
34234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34235       };
34236     } catch (std::exception& e) {
34237       {
34238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34239       };
34240     } catch (Dali::DaliException e) {
34241       {
34242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34243       };
34244     } catch (...) {
34245       {
34246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34247       };
34248     }
34249   }
34250
34251   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34252   return jresult;
34253 }
34254
34255
34256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34257   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34258   float arg2 ;
34259   float arg3 ;
34260
34261   arg1 = (Dali::Actor *)jarg1;
34262   arg2 = (float)jarg2;
34263   arg3 = (float)jarg3;
34264   {
34265     try {
34266       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
34267     } catch (std::out_of_range& e) {
34268       {
34269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34270       };
34271     } catch (std::exception& e) {
34272       {
34273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34274       };
34275     } catch (Dali::DaliException e) {
34276       {
34277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34278       };
34279     } catch (...) {
34280       {
34281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34282       };
34283     }
34284   }
34285
34286 }
34287
34288
34289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34290   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34291   float arg2 ;
34292   float arg3 ;
34293   float arg4 ;
34294
34295   arg1 = (Dali::Actor *)jarg1;
34296   arg2 = (float)jarg2;
34297   arg3 = (float)jarg3;
34298   arg4 = (float)jarg4;
34299   {
34300     try {
34301       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
34302     } catch (std::out_of_range& e) {
34303       {
34304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34305       };
34306     } catch (std::exception& e) {
34307       {
34308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34309       };
34310     } catch (Dali::DaliException e) {
34311       {
34312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34313       };
34314     } catch (...) {
34315       {
34316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34317       };
34318     }
34319   }
34320
34321 }
34322
34323
34324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34325   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34326   Dali::Vector2 *arg2 = 0 ;
34327
34328   arg1 = (Dali::Actor *)jarg1;
34329   arg2 = (Dali::Vector2 *)jarg2;
34330   if (!arg2) {
34331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34332     return ;
34333   }
34334   {
34335     try {
34336       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
34337     } catch (std::out_of_range& e) {
34338       {
34339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34340       };
34341     } catch (std::exception& e) {
34342       {
34343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34344       };
34345     } catch (Dali::DaliException e) {
34346       {
34347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34348       };
34349     } catch (...) {
34350       {
34351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34352       };
34353     }
34354   }
34355
34356 }
34357
34358
34359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34360   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34361   Dali::Vector3 *arg2 = 0 ;
34362
34363   arg1 = (Dali::Actor *)jarg1;
34364   arg2 = (Dali::Vector3 *)jarg2;
34365   if (!arg2) {
34366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34367     return ;
34368   }
34369   {
34370     try {
34371       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
34372     } catch (std::out_of_range& e) {
34373       {
34374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34375       };
34376     } catch (std::exception& e) {
34377       {
34378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34379       };
34380     } catch (Dali::DaliException e) {
34381       {
34382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34383       };
34384     } catch (...) {
34385       {
34386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34387       };
34388     }
34389   }
34390
34391 }
34392
34393
34394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34395   void * jresult ;
34396   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34397   Dali::Vector3 result;
34398
34399   arg1 = (Dali::Actor *)jarg1;
34400   {
34401     try {
34402       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34403     } catch (std::out_of_range& e) {
34404       {
34405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34406       };
34407     } catch (std::exception& e) {
34408       {
34409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34410       };
34411     } catch (Dali::DaliException e) {
34412       {
34413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34414       };
34415     } catch (...) {
34416       {
34417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34418       };
34419     }
34420   }
34421
34422   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34423   return jresult;
34424 }
34425
34426
34427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34428   void * jresult ;
34429   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34430   Dali::Vector3 result;
34431
34432   arg1 = (Dali::Actor *)jarg1;
34433   {
34434     try {
34435       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
34436     } catch (std::out_of_range& e) {
34437       {
34438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34439       };
34440     } catch (std::exception& e) {
34441       {
34442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34443       };
34444     } catch (Dali::DaliException e) {
34445       {
34446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34447       };
34448     } catch (...) {
34449       {
34450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34451       };
34452     }
34453   }
34454
34455   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34456   return jresult;
34457 }
34458
34459
34460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34461   void * jresult ;
34462   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34463   Dali::Vector3 result;
34464
34465   arg1 = (Dali::Actor *)jarg1;
34466   {
34467     try {
34468       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34469     } catch (std::out_of_range& e) {
34470       {
34471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34472       };
34473     } catch (std::exception& e) {
34474       {
34475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34476       };
34477     } catch (Dali::DaliException e) {
34478       {
34479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34480       };
34481     } catch (...) {
34482       {
34483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34484       };
34485     }
34486   }
34487
34488   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34489   return jresult;
34490 }
34491
34492
34493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34494   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34495   float arg2 ;
34496   float arg3 ;
34497
34498   arg1 = (Dali::Actor *)jarg1;
34499   arg2 = (float)jarg2;
34500   arg3 = (float)jarg3;
34501   {
34502     try {
34503       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
34504     } catch (std::out_of_range& e) {
34505       {
34506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34507       };
34508     } catch (std::exception& e) {
34509       {
34510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34511       };
34512     } catch (Dali::DaliException e) {
34513       {
34514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34515       };
34516     } catch (...) {
34517       {
34518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34519       };
34520     }
34521   }
34522
34523 }
34524
34525
34526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34527   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34528   float arg2 ;
34529   float arg3 ;
34530   float arg4 ;
34531
34532   arg1 = (Dali::Actor *)jarg1;
34533   arg2 = (float)jarg2;
34534   arg3 = (float)jarg3;
34535   arg4 = (float)jarg4;
34536   {
34537     try {
34538       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
34539     } catch (std::out_of_range& e) {
34540       {
34541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34542       };
34543     } catch (std::exception& e) {
34544       {
34545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34546       };
34547     } catch (Dali::DaliException e) {
34548       {
34549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34550       };
34551     } catch (...) {
34552       {
34553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34554       };
34555     }
34556   }
34557
34558 }
34559
34560
34561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34562   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34563   Dali::Vector3 *arg2 = 0 ;
34564
34565   arg1 = (Dali::Actor *)jarg1;
34566   arg2 = (Dali::Vector3 *)jarg2;
34567   if (!arg2) {
34568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34569     return ;
34570   }
34571   {
34572     try {
34573       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
34574     } catch (std::out_of_range& e) {
34575       {
34576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34577       };
34578     } catch (std::exception& e) {
34579       {
34580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34581       };
34582     } catch (Dali::DaliException e) {
34583       {
34584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34585       };
34586     } catch (...) {
34587       {
34588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34589       };
34590     }
34591   }
34592
34593 }
34594
34595
34596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34597   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34598   float arg2 ;
34599
34600   arg1 = (Dali::Actor *)jarg1;
34601   arg2 = (float)jarg2;
34602   {
34603     try {
34604       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
34605     } catch (std::out_of_range& e) {
34606       {
34607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34608       };
34609     } catch (std::exception& e) {
34610       {
34611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34612       };
34613     } catch (Dali::DaliException e) {
34614       {
34615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34616       };
34617     } catch (...) {
34618       {
34619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34620       };
34621     }
34622   }
34623
34624 }
34625
34626
34627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34628   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34629   float arg2 ;
34630
34631   arg1 = (Dali::Actor *)jarg1;
34632   arg2 = (float)jarg2;
34633   {
34634     try {
34635       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
34636     } catch (std::out_of_range& e) {
34637       {
34638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34639       };
34640     } catch (std::exception& e) {
34641       {
34642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34643       };
34644     } catch (Dali::DaliException e) {
34645       {
34646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34647       };
34648     } catch (...) {
34649       {
34650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34651       };
34652     }
34653   }
34654
34655 }
34656
34657
34658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34659   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34660   float arg2 ;
34661
34662   arg1 = (Dali::Actor *)jarg1;
34663   arg2 = (float)jarg2;
34664   {
34665     try {
34666       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
34667     } catch (std::out_of_range& e) {
34668       {
34669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34670       };
34671     } catch (std::exception& e) {
34672       {
34673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34674       };
34675     } catch (Dali::DaliException e) {
34676       {
34677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34678       };
34679     } catch (...) {
34680       {
34681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34682       };
34683     }
34684   }
34685
34686 }
34687
34688
34689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34690   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34691   Dali::Vector3 *arg2 = 0 ;
34692
34693   arg1 = (Dali::Actor *)jarg1;
34694   arg2 = (Dali::Vector3 *)jarg2;
34695   if (!arg2) {
34696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34697     return ;
34698   }
34699   {
34700     try {
34701       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34702     } catch (std::out_of_range& e) {
34703       {
34704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34705       };
34706     } catch (std::exception& e) {
34707       {
34708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34709       };
34710     } catch (Dali::DaliException e) {
34711       {
34712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34713       };
34714     } catch (...) {
34715       {
34716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34717       };
34718     }
34719   }
34720
34721 }
34722
34723
34724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34725   void * jresult ;
34726   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34727   Dali::Vector3 result;
34728
34729   arg1 = (Dali::Actor *)jarg1;
34730   {
34731     try {
34732       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
34733     } catch (std::out_of_range& e) {
34734       {
34735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34736       };
34737     } catch (std::exception& e) {
34738       {
34739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34740       };
34741     } catch (Dali::DaliException e) {
34742       {
34743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34744       };
34745     } catch (...) {
34746       {
34747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34748       };
34749     }
34750   }
34751
34752   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34753   return jresult;
34754 }
34755
34756
34757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34758   void * jresult ;
34759   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34760   Dali::Vector3 result;
34761
34762   arg1 = (Dali::Actor *)jarg1;
34763   {
34764     try {
34765       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
34766     } catch (std::out_of_range& e) {
34767       {
34768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34769       };
34770     } catch (std::exception& e) {
34771       {
34772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34773       };
34774     } catch (Dali::DaliException e) {
34775       {
34776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34777       };
34778     } catch (...) {
34779       {
34780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34781       };
34782     }
34783   }
34784
34785   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34786   return jresult;
34787 }
34788
34789
34790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34791   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34792   bool arg2 ;
34793
34794   arg1 = (Dali::Actor *)jarg1;
34795   arg2 = jarg2 ? true : false;
34796   {
34797     try {
34798       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
34799     } catch (std::out_of_range& e) {
34800       {
34801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34802       };
34803     } catch (std::exception& e) {
34804       {
34805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34806       };
34807     } catch (Dali::DaliException e) {
34808       {
34809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34810       };
34811     } catch (...) {
34812       {
34813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34814       };
34815     }
34816   }
34817
34818 }
34819
34820
34821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34822   unsigned int jresult ;
34823   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34824   bool result;
34825
34826   arg1 = (Dali::Actor *)jarg1;
34827   {
34828     try {
34829       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
34830     } catch (std::out_of_range& e) {
34831       {
34832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34833       };
34834     } catch (std::exception& e) {
34835       {
34836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34837       };
34838     } catch (Dali::DaliException e) {
34839       {
34840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34841       };
34842     } catch (...) {
34843       {
34844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34845       };
34846     }
34847   }
34848
34849   jresult = result;
34850   return jresult;
34851 }
34852
34853
34854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34855   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34856   Dali::Degree *arg2 = 0 ;
34857   Dali::Vector3 *arg3 = 0 ;
34858
34859   arg1 = (Dali::Actor *)jarg1;
34860   arg2 = (Dali::Degree *)jarg2;
34861   if (!arg2) {
34862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34863     return ;
34864   }
34865   arg3 = (Dali::Vector3 *)jarg3;
34866   if (!arg3) {
34867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34868     return ;
34869   }
34870   {
34871     try {
34872       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34873     } catch (std::out_of_range& e) {
34874       {
34875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34876       };
34877     } catch (std::exception& e) {
34878       {
34879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34880       };
34881     } catch (Dali::DaliException e) {
34882       {
34883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34884       };
34885     } catch (...) {
34886       {
34887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34888       };
34889     }
34890   }
34891
34892 }
34893
34894
34895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34896   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34897   Dali::Radian *arg2 = 0 ;
34898   Dali::Vector3 *arg3 = 0 ;
34899
34900   arg1 = (Dali::Actor *)jarg1;
34901   arg2 = (Dali::Radian *)jarg2;
34902   if (!arg2) {
34903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34904     return ;
34905   }
34906   arg3 = (Dali::Vector3 *)jarg3;
34907   if (!arg3) {
34908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34909     return ;
34910   }
34911   {
34912     try {
34913       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34914     } catch (std::out_of_range& e) {
34915       {
34916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34917       };
34918     } catch (std::exception& e) {
34919       {
34920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34921       };
34922     } catch (Dali::DaliException e) {
34923       {
34924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34925       };
34926     } catch (...) {
34927       {
34928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34929       };
34930     }
34931   }
34932
34933 }
34934
34935
34936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34937   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34938   Dali::Quaternion *arg2 = 0 ;
34939
34940   arg1 = (Dali::Actor *)jarg1;
34941   arg2 = (Dali::Quaternion *)jarg2;
34942   if (!arg2) {
34943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34944     return ;
34945   }
34946   {
34947     try {
34948       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
34949     } catch (std::out_of_range& e) {
34950       {
34951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34952       };
34953     } catch (std::exception& e) {
34954       {
34955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34956       };
34957     } catch (Dali::DaliException e) {
34958       {
34959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34960       };
34961     } catch (...) {
34962       {
34963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34964       };
34965     }
34966   }
34967
34968 }
34969
34970
34971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34972   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34973   Dali::Degree *arg2 = 0 ;
34974   Dali::Vector3 *arg3 = 0 ;
34975
34976   arg1 = (Dali::Actor *)jarg1;
34977   arg2 = (Dali::Degree *)jarg2;
34978   if (!arg2) {
34979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34980     return ;
34981   }
34982   arg3 = (Dali::Vector3 *)jarg3;
34983   if (!arg3) {
34984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34985     return ;
34986   }
34987   {
34988     try {
34989       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34990     } catch (std::out_of_range& e) {
34991       {
34992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34993       };
34994     } catch (std::exception& e) {
34995       {
34996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34997       };
34998     } catch (Dali::DaliException e) {
34999       {
35000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35001       };
35002     } catch (...) {
35003       {
35004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35005       };
35006     }
35007   }
35008
35009 }
35010
35011
35012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35013   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35014   Dali::Radian *arg2 = 0 ;
35015   Dali::Vector3 *arg3 = 0 ;
35016
35017   arg1 = (Dali::Actor *)jarg1;
35018   arg2 = (Dali::Radian *)jarg2;
35019   if (!arg2) {
35020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35021     return ;
35022   }
35023   arg3 = (Dali::Vector3 *)jarg3;
35024   if (!arg3) {
35025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35026     return ;
35027   }
35028   {
35029     try {
35030       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35031     } catch (std::out_of_range& e) {
35032       {
35033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35034       };
35035     } catch (std::exception& e) {
35036       {
35037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35038       };
35039     } catch (Dali::DaliException e) {
35040       {
35041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35042       };
35043     } catch (...) {
35044       {
35045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35046       };
35047     }
35048   }
35049
35050 }
35051
35052
35053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35054   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35055   Dali::Quaternion *arg2 = 0 ;
35056
35057   arg1 = (Dali::Actor *)jarg1;
35058   arg2 = (Dali::Quaternion *)jarg2;
35059   if (!arg2) {
35060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35061     return ;
35062   }
35063   {
35064     try {
35065       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35066     } catch (std::out_of_range& e) {
35067       {
35068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35069       };
35070     } catch (std::exception& e) {
35071       {
35072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35073       };
35074     } catch (Dali::DaliException e) {
35075       {
35076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35077       };
35078     } catch (...) {
35079       {
35080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35081       };
35082     }
35083   }
35084
35085 }
35086
35087
35088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35089   void * jresult ;
35090   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35091   Dali::Quaternion result;
35092
35093   arg1 = (Dali::Actor *)jarg1;
35094   {
35095     try {
35096       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
35097     } catch (std::out_of_range& e) {
35098       {
35099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35100       };
35101     } catch (std::exception& e) {
35102       {
35103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35104       };
35105     } catch (Dali::DaliException e) {
35106       {
35107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35108       };
35109     } catch (...) {
35110       {
35111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35112       };
35113     }
35114   }
35115
35116   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35117   return jresult;
35118 }
35119
35120
35121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35122   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35123   bool arg2 ;
35124
35125   arg1 = (Dali::Actor *)jarg1;
35126   arg2 = jarg2 ? true : false;
35127   {
35128     try {
35129       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
35130     } catch (std::out_of_range& e) {
35131       {
35132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35133       };
35134     } catch (std::exception& e) {
35135       {
35136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35137       };
35138     } catch (Dali::DaliException e) {
35139       {
35140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35141       };
35142     } catch (...) {
35143       {
35144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35145       };
35146     }
35147   }
35148
35149 }
35150
35151
35152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35153   unsigned int jresult ;
35154   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35155   bool result;
35156
35157   arg1 = (Dali::Actor *)jarg1;
35158   {
35159     try {
35160       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
35161     } catch (std::out_of_range& e) {
35162       {
35163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35164       };
35165     } catch (std::exception& e) {
35166       {
35167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35168       };
35169     } catch (Dali::DaliException e) {
35170       {
35171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35172       };
35173     } catch (...) {
35174       {
35175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35176       };
35177     }
35178   }
35179
35180   jresult = result;
35181   return jresult;
35182 }
35183
35184
35185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35186   void * jresult ;
35187   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35188   Dali::Quaternion result;
35189
35190   arg1 = (Dali::Actor *)jarg1;
35191   {
35192     try {
35193       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
35194     } catch (std::out_of_range& e) {
35195       {
35196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35197       };
35198     } catch (std::exception& e) {
35199       {
35200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35201       };
35202     } catch (Dali::DaliException e) {
35203       {
35204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35205       };
35206     } catch (...) {
35207       {
35208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35209       };
35210     }
35211   }
35212
35213   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35214   return jresult;
35215 }
35216
35217
35218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35219   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35220   float arg2 ;
35221
35222   arg1 = (Dali::Actor *)jarg1;
35223   arg2 = (float)jarg2;
35224   {
35225     try {
35226       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
35227     } catch (std::out_of_range& e) {
35228       {
35229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35230       };
35231     } catch (std::exception& e) {
35232       {
35233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35234       };
35235     } catch (Dali::DaliException e) {
35236       {
35237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35238       };
35239     } catch (...) {
35240       {
35241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35242       };
35243     }
35244   }
35245
35246 }
35247
35248
35249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35250   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35251   float arg2 ;
35252   float arg3 ;
35253   float arg4 ;
35254
35255   arg1 = (Dali::Actor *)jarg1;
35256   arg2 = (float)jarg2;
35257   arg3 = (float)jarg3;
35258   arg4 = (float)jarg4;
35259   {
35260     try {
35261       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
35262     } catch (std::out_of_range& e) {
35263       {
35264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35265       };
35266     } catch (std::exception& e) {
35267       {
35268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35269       };
35270     } catch (Dali::DaliException e) {
35271       {
35272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35273       };
35274     } catch (...) {
35275       {
35276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35277       };
35278     }
35279   }
35280
35281 }
35282
35283
35284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35285   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35286   Dali::Vector3 *arg2 = 0 ;
35287
35288   arg1 = (Dali::Actor *)jarg1;
35289   arg2 = (Dali::Vector3 *)jarg2;
35290   if (!arg2) {
35291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35292     return ;
35293   }
35294   {
35295     try {
35296       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
35297     } catch (std::out_of_range& e) {
35298       {
35299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35300       };
35301     } catch (std::exception& e) {
35302       {
35303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35304       };
35305     } catch (Dali::DaliException e) {
35306       {
35307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35308       };
35309     } catch (...) {
35310       {
35311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35312       };
35313     }
35314   }
35315
35316 }
35317
35318
35319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35320   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35321   Dali::Vector3 *arg2 = 0 ;
35322
35323   arg1 = (Dali::Actor *)jarg1;
35324   arg2 = (Dali::Vector3 *)jarg2;
35325   if (!arg2) {
35326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35327     return ;
35328   }
35329   {
35330     try {
35331       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35332     } catch (std::out_of_range& e) {
35333       {
35334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35335       };
35336     } catch (std::exception& e) {
35337       {
35338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35339       };
35340     } catch (Dali::DaliException e) {
35341       {
35342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35343       };
35344     } catch (...) {
35345       {
35346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35347       };
35348     }
35349   }
35350
35351 }
35352
35353
35354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35355   void * jresult ;
35356   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35357   Dali::Vector3 result;
35358
35359   arg1 = (Dali::Actor *)jarg1;
35360   {
35361     try {
35362       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
35363     } catch (std::out_of_range& e) {
35364       {
35365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35366       };
35367     } catch (std::exception& e) {
35368       {
35369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35370       };
35371     } catch (Dali::DaliException e) {
35372       {
35373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35374       };
35375     } catch (...) {
35376       {
35377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35378       };
35379     }
35380   }
35381
35382   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35383   return jresult;
35384 }
35385
35386
35387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35388   void * jresult ;
35389   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35390   Dali::Vector3 result;
35391
35392   arg1 = (Dali::Actor *)jarg1;
35393   {
35394     try {
35395       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
35396     } catch (std::out_of_range& e) {
35397       {
35398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35399       };
35400     } catch (std::exception& e) {
35401       {
35402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35403       };
35404     } catch (Dali::DaliException e) {
35405       {
35406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35407       };
35408     } catch (...) {
35409       {
35410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35411       };
35412     }
35413   }
35414
35415   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35416   return jresult;
35417 }
35418
35419
35420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35421   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35422   bool arg2 ;
35423
35424   arg1 = (Dali::Actor *)jarg1;
35425   arg2 = jarg2 ? true : false;
35426   {
35427     try {
35428       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
35429     } catch (std::out_of_range& e) {
35430       {
35431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35432       };
35433     } catch (std::exception& e) {
35434       {
35435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35436       };
35437     } catch (Dali::DaliException e) {
35438       {
35439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35440       };
35441     } catch (...) {
35442       {
35443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35444       };
35445     }
35446   }
35447
35448 }
35449
35450
35451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35452   unsigned int jresult ;
35453   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35454   bool result;
35455
35456   arg1 = (Dali::Actor *)jarg1;
35457   {
35458     try {
35459       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
35460     } catch (std::out_of_range& e) {
35461       {
35462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35463       };
35464     } catch (std::exception& e) {
35465       {
35466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35467       };
35468     } catch (Dali::DaliException e) {
35469       {
35470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35471       };
35472     } catch (...) {
35473       {
35474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35475       };
35476     }
35477   }
35478
35479   jresult = result;
35480   return jresult;
35481 }
35482
35483
35484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35485   void * jresult ;
35486   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35487   Dali::Matrix result;
35488
35489   arg1 = (Dali::Actor *)jarg1;
35490   {
35491     try {
35492       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
35493     } catch (std::out_of_range& e) {
35494       {
35495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35496       };
35497     } catch (std::exception& e) {
35498       {
35499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35500       };
35501     } catch (Dali::DaliException e) {
35502       {
35503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35504       };
35505     } catch (...) {
35506       {
35507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35508       };
35509     }
35510   }
35511
35512   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35513   return jresult;
35514 }
35515
35516
35517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35518   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35519   bool arg2 ;
35520
35521   arg1 = (Dali::Actor *)jarg1;
35522   arg2 = jarg2 ? true : false;
35523   {
35524     try {
35525       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
35526     } catch (std::out_of_range& e) {
35527       {
35528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35529       };
35530     } catch (std::exception& e) {
35531       {
35532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35533       };
35534     } catch (Dali::DaliException e) {
35535       {
35536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35537       };
35538     } catch (...) {
35539       {
35540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35541       };
35542     }
35543   }
35544
35545 }
35546
35547
35548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35549   unsigned int jresult ;
35550   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35551   bool result;
35552
35553   arg1 = (Dali::Actor *)jarg1;
35554   {
35555     try {
35556       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
35557     } catch (std::out_of_range& e) {
35558       {
35559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35560       };
35561     } catch (std::exception& e) {
35562       {
35563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35564       };
35565     } catch (Dali::DaliException e) {
35566       {
35567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35568       };
35569     } catch (...) {
35570       {
35571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35572       };
35573     }
35574   }
35575
35576   jresult = result;
35577   return jresult;
35578 }
35579
35580
35581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35582   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35583   float arg2 ;
35584
35585   arg1 = (Dali::Actor *)jarg1;
35586   arg2 = (float)jarg2;
35587   {
35588     try {
35589       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
35590     } catch (std::out_of_range& e) {
35591       {
35592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35593       };
35594     } catch (std::exception& e) {
35595       {
35596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35597       };
35598     } catch (Dali::DaliException e) {
35599       {
35600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35601       };
35602     } catch (...) {
35603       {
35604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35605       };
35606     }
35607   }
35608
35609 }
35610
35611
35612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35613   float jresult ;
35614   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35615   float result;
35616
35617   arg1 = (Dali::Actor *)jarg1;
35618   {
35619     try {
35620       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
35621     } catch (std::out_of_range& e) {
35622       {
35623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35624       };
35625     } catch (std::exception& e) {
35626       {
35627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35628       };
35629     } catch (Dali::DaliException e) {
35630       {
35631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35632       };
35633     } catch (...) {
35634       {
35635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35636       };
35637     }
35638   }
35639
35640   jresult = result;
35641   return jresult;
35642 }
35643
35644
35645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35646   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35647   Dali::Vector4 *arg2 = 0 ;
35648
35649   arg1 = (Dali::Actor *)jarg1;
35650   arg2 = (Dali::Vector4 *)jarg2;
35651   if (!arg2) {
35652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35653     return ;
35654   }
35655   {
35656     try {
35657       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
35658     } catch (std::out_of_range& e) {
35659       {
35660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35661       };
35662     } catch (std::exception& e) {
35663       {
35664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35665       };
35666     } catch (Dali::DaliException e) {
35667       {
35668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35669       };
35670     } catch (...) {
35671       {
35672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35673       };
35674     }
35675   }
35676
35677 }
35678
35679
35680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35681   void * jresult ;
35682   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35683   Dali::Vector4 result;
35684
35685   arg1 = (Dali::Actor *)jarg1;
35686   {
35687     try {
35688       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
35689     } catch (std::out_of_range& e) {
35690       {
35691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35692       };
35693     } catch (std::exception& e) {
35694       {
35695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35696       };
35697     } catch (Dali::DaliException e) {
35698       {
35699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35700       };
35701     } catch (...) {
35702       {
35703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35704       };
35705     }
35706   }
35707
35708   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35709   return jresult;
35710 }
35711
35712
35713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35714   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35715   Dali::ColorMode arg2 ;
35716
35717   arg1 = (Dali::Actor *)jarg1;
35718   arg2 = (Dali::ColorMode)jarg2;
35719   {
35720     try {
35721       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
35722     } catch (std::out_of_range& e) {
35723       {
35724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35725       };
35726     } catch (std::exception& e) {
35727       {
35728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35729       };
35730     } catch (Dali::DaliException e) {
35731       {
35732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35733       };
35734     } catch (...) {
35735       {
35736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35737       };
35738     }
35739   }
35740
35741 }
35742
35743
35744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35745   int jresult ;
35746   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35747   Dali::ColorMode result;
35748
35749   arg1 = (Dali::Actor *)jarg1;
35750   {
35751     try {
35752       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
35753     } catch (std::out_of_range& e) {
35754       {
35755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35756       };
35757     } catch (std::exception& e) {
35758       {
35759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35760       };
35761     } catch (Dali::DaliException e) {
35762       {
35763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35764       };
35765     } catch (...) {
35766       {
35767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35768       };
35769     }
35770   }
35771
35772   jresult = (int)result;
35773   return jresult;
35774 }
35775
35776
35777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35778   void * jresult ;
35779   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35780   Dali::Vector4 result;
35781
35782   arg1 = (Dali::Actor *)jarg1;
35783   {
35784     try {
35785       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
35786     } catch (std::out_of_range& e) {
35787       {
35788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35789       };
35790     } catch (std::exception& e) {
35791       {
35792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35793       };
35794     } catch (Dali::DaliException e) {
35795       {
35796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35797       };
35798     } catch (...) {
35799       {
35800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35801       };
35802     }
35803   }
35804
35805   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35806   return jresult;
35807 }
35808
35809
35810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35811   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35812   Dali::DrawMode::Type arg2 ;
35813
35814   arg1 = (Dali::Actor *)jarg1;
35815   arg2 = (Dali::DrawMode::Type)jarg2;
35816   {
35817     try {
35818       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
35819     } catch (std::out_of_range& e) {
35820       {
35821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35822       };
35823     } catch (std::exception& e) {
35824       {
35825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35826       };
35827     } catch (Dali::DaliException e) {
35828       {
35829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35830       };
35831     } catch (...) {
35832       {
35833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35834       };
35835     }
35836   }
35837
35838 }
35839
35840
35841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35842   int jresult ;
35843   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35844   Dali::DrawMode::Type result;
35845
35846   arg1 = (Dali::Actor *)jarg1;
35847   {
35848     try {
35849       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
35850     } catch (std::out_of_range& e) {
35851       {
35852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35853       };
35854     } catch (std::exception& e) {
35855       {
35856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35857       };
35858     } catch (Dali::DaliException e) {
35859       {
35860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35861       };
35862     } catch (...) {
35863       {
35864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35865       };
35866     }
35867   }
35868
35869   jresult = (int)result;
35870   return jresult;
35871 }
35872
35873
35874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35875   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35876   bool arg2 ;
35877
35878   arg1 = (Dali::Actor *)jarg1;
35879   arg2 = jarg2 ? true : false;
35880   {
35881     try {
35882       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
35883     } catch (std::out_of_range& e) {
35884       {
35885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35886       };
35887     } catch (std::exception& e) {
35888       {
35889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35890       };
35891     } catch (Dali::DaliException e) {
35892       {
35893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35894       };
35895     } catch (...) {
35896       {
35897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35898       };
35899     }
35900   }
35901
35902 }
35903
35904
35905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35906   unsigned int jresult ;
35907   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35908   bool result;
35909
35910   arg1 = (Dali::Actor *)jarg1;
35911   {
35912     try {
35913       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
35914     } catch (std::out_of_range& e) {
35915       {
35916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35917       };
35918     } catch (std::exception& e) {
35919       {
35920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35921       };
35922     } catch (Dali::DaliException e) {
35923       {
35924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35925       };
35926     } catch (...) {
35927       {
35928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35929       };
35930     }
35931   }
35932
35933   jresult = result;
35934   return jresult;
35935 }
35936
35937
35938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35939   unsigned int jresult ;
35940   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35941   float *arg2 = 0 ;
35942   float *arg3 = 0 ;
35943   float arg4 ;
35944   float arg5 ;
35945   bool result;
35946
35947   arg1 = (Dali::Actor *)jarg1;
35948   arg2 = (float *)jarg2;
35949   arg3 = (float *)jarg3;
35950   arg4 = (float)jarg4;
35951   arg5 = (float)jarg5;
35952   {
35953     try {
35954       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35955     } catch (std::out_of_range& e) {
35956       {
35957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35958       };
35959     } catch (std::exception& e) {
35960       {
35961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35962       };
35963     } catch (Dali::DaliException e) {
35964       {
35965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35966       };
35967     } catch (...) {
35968       {
35969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35970       };
35971     }
35972   }
35973
35974   jresult = result;
35975   return jresult;
35976 }
35977
35978
35979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
35980   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35981   bool arg2 ;
35982
35983   arg1 = (Dali::Actor *)jarg1;
35984   arg2 = jarg2 ? true : false;
35985   {
35986     try {
35987       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
35988     } catch (std::out_of_range& e) {
35989       {
35990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35991       };
35992     } catch (std::exception& e) {
35993       {
35994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35995       };
35996     } catch (Dali::DaliException e) {
35997       {
35998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35999       };
36000     } catch (...) {
36001       {
36002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36003       };
36004     }
36005   }
36006
36007 }
36008
36009
36010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36011   unsigned int jresult ;
36012   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36013   bool result;
36014
36015   arg1 = (Dali::Actor *)jarg1;
36016   {
36017     try {
36018       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
36019     } catch (std::out_of_range& e) {
36020       {
36021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36022       };
36023     } catch (std::exception& e) {
36024       {
36025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36026       };
36027     } catch (Dali::DaliException e) {
36028       {
36029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36030       };
36031     } catch (...) {
36032       {
36033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36034       };
36035     }
36036   }
36037
36038   jresult = result;
36039   return jresult;
36040 }
36041
36042
36043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36044   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36045   bool arg2 ;
36046
36047   arg1 = (Dali::Actor *)jarg1;
36048   arg2 = jarg2 ? true : false;
36049   {
36050     try {
36051       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
36052     } catch (std::out_of_range& e) {
36053       {
36054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36055       };
36056     } catch (std::exception& e) {
36057       {
36058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36059       };
36060     } catch (Dali::DaliException e) {
36061       {
36062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36063       };
36064     } catch (...) {
36065       {
36066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36067       };
36068     }
36069   }
36070
36071 }
36072
36073
36074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36075   unsigned int jresult ;
36076   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36077   bool result;
36078
36079   arg1 = (Dali::Actor *)jarg1;
36080   {
36081     try {
36082       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
36083     } catch (std::out_of_range& e) {
36084       {
36085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36086       };
36087     } catch (std::exception& e) {
36088       {
36089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36090       };
36091     } catch (Dali::DaliException e) {
36092       {
36093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36094       };
36095     } catch (...) {
36096       {
36097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36098       };
36099     }
36100   }
36101
36102   jresult = result;
36103   return jresult;
36104 }
36105
36106
36107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36108   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36109   Dali::ResizePolicy::Type arg2 ;
36110   Dali::Dimension::Type arg3 ;
36111
36112   arg1 = (Dali::Actor *)jarg1;
36113   arg2 = (Dali::ResizePolicy::Type)jarg2;
36114   arg3 = (Dali::Dimension::Type)jarg3;
36115   {
36116     try {
36117       (arg1)->SetResizePolicy(arg2,arg3);
36118     } catch (std::out_of_range& e) {
36119       {
36120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36121       };
36122     } catch (std::exception& e) {
36123       {
36124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36125       };
36126     } catch (Dali::DaliException e) {
36127       {
36128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36129       };
36130     } catch (...) {
36131       {
36132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36133       };
36134     }
36135   }
36136
36137 }
36138
36139
36140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36141   int jresult ;
36142   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36143   Dali::Dimension::Type arg2 ;
36144   Dali::ResizePolicy::Type result;
36145
36146   arg1 = (Dali::Actor *)jarg1;
36147   arg2 = (Dali::Dimension::Type)jarg2;
36148   {
36149     try {
36150       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36151     } catch (std::out_of_range& e) {
36152       {
36153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36154       };
36155     } catch (std::exception& e) {
36156       {
36157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36158       };
36159     } catch (Dali::DaliException e) {
36160       {
36161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36162       };
36163     } catch (...) {
36164       {
36165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36166       };
36167     }
36168   }
36169
36170   jresult = (int)result;
36171   return jresult;
36172 }
36173
36174
36175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36176   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36177   Dali::SizeScalePolicy::Type arg2 ;
36178
36179   arg1 = (Dali::Actor *)jarg1;
36180   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36181   {
36182     try {
36183       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
36184     } catch (std::out_of_range& e) {
36185       {
36186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36187       };
36188     } catch (std::exception& e) {
36189       {
36190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36191       };
36192     } catch (Dali::DaliException e) {
36193       {
36194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36195       };
36196     } catch (...) {
36197       {
36198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36199       };
36200     }
36201   }
36202
36203 }
36204
36205
36206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36207   int jresult ;
36208   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36209   Dali::SizeScalePolicy::Type result;
36210
36211   arg1 = (Dali::Actor *)jarg1;
36212   {
36213     try {
36214       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
36215     } catch (std::out_of_range& e) {
36216       {
36217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36218       };
36219     } catch (std::exception& e) {
36220       {
36221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36222       };
36223     } catch (Dali::DaliException e) {
36224       {
36225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36226       };
36227     } catch (...) {
36228       {
36229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36230       };
36231     }
36232   }
36233
36234   jresult = (int)result;
36235   return jresult;
36236 }
36237
36238
36239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36240   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36241   Dali::Vector3 *arg2 = 0 ;
36242
36243   arg1 = (Dali::Actor *)jarg1;
36244   arg2 = (Dali::Vector3 *)jarg2;
36245   if (!arg2) {
36246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36247     return ;
36248   }
36249   {
36250     try {
36251       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
36252     } catch (std::out_of_range& e) {
36253       {
36254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36255       };
36256     } catch (std::exception& e) {
36257       {
36258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36259       };
36260     } catch (Dali::DaliException e) {
36261       {
36262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36263       };
36264     } catch (...) {
36265       {
36266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36267       };
36268     }
36269   }
36270
36271 }
36272
36273
36274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36275   void * jresult ;
36276   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36277   Dali::Vector3 result;
36278
36279   arg1 = (Dali::Actor *)jarg1;
36280   {
36281     try {
36282       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
36283     } catch (std::out_of_range& e) {
36284       {
36285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36286       };
36287     } catch (std::exception& e) {
36288       {
36289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36290       };
36291     } catch (Dali::DaliException e) {
36292       {
36293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36294       };
36295     } catch (...) {
36296       {
36297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36298       };
36299     }
36300   }
36301
36302   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36303   return jresult;
36304 }
36305
36306
36307 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36308   float jresult ;
36309   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36310   float arg2 ;
36311   float result;
36312
36313   arg1 = (Dali::Actor *)jarg1;
36314   arg2 = (float)jarg2;
36315   {
36316     try {
36317       result = (float)(arg1)->GetHeightForWidth(arg2);
36318     } catch (std::out_of_range& e) {
36319       {
36320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36321       };
36322     } catch (std::exception& e) {
36323       {
36324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36325       };
36326     } catch (Dali::DaliException e) {
36327       {
36328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36329       };
36330     } catch (...) {
36331       {
36332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36333       };
36334     }
36335   }
36336
36337   jresult = result;
36338   return jresult;
36339 }
36340
36341
36342 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36343   float jresult ;
36344   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36345   float arg2 ;
36346   float result;
36347
36348   arg1 = (Dali::Actor *)jarg1;
36349   arg2 = (float)jarg2;
36350   {
36351     try {
36352       result = (float)(arg1)->GetWidthForHeight(arg2);
36353     } catch (std::out_of_range& e) {
36354       {
36355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36356       };
36357     } catch (std::exception& e) {
36358       {
36359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36360       };
36361     } catch (Dali::DaliException e) {
36362       {
36363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36364       };
36365     } catch (...) {
36366       {
36367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36368       };
36369     }
36370   }
36371
36372   jresult = result;
36373   return jresult;
36374 }
36375
36376
36377 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36378   float jresult ;
36379   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36380   Dali::Dimension::Type arg2 ;
36381   float result;
36382
36383   arg1 = (Dali::Actor *)jarg1;
36384   arg2 = (Dali::Dimension::Type)jarg2;
36385   {
36386     try {
36387       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36388     } catch (std::out_of_range& e) {
36389       {
36390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36391       };
36392     } catch (std::exception& e) {
36393       {
36394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36395       };
36396     } catch (Dali::DaliException e) {
36397       {
36398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36399       };
36400     } catch (...) {
36401       {
36402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36403       };
36404     }
36405   }
36406
36407   jresult = result;
36408   return jresult;
36409 }
36410
36411
36412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36413   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36414   Dali::Padding *arg2 = 0 ;
36415
36416   arg1 = (Dali::Actor *)jarg1;
36417   arg2 = (Dali::Padding *)jarg2;
36418   if (!arg2) {
36419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36420     return ;
36421   }
36422   {
36423     try {
36424       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
36425     } catch (std::out_of_range& e) {
36426       {
36427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36428       };
36429     } catch (std::exception& e) {
36430       {
36431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36432       };
36433     } catch (Dali::DaliException e) {
36434       {
36435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36436       };
36437     } catch (...) {
36438       {
36439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36440       };
36441     }
36442   }
36443
36444 }
36445
36446
36447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36448   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36449   Dali::Padding *arg2 = 0 ;
36450
36451   arg1 = (Dali::Actor *)jarg1;
36452   arg2 = (Dali::Padding *)jarg2;
36453   if (!arg2) {
36454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36455     return ;
36456   }
36457   {
36458     try {
36459       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
36460     } catch (std::out_of_range& e) {
36461       {
36462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36463       };
36464     } catch (std::exception& e) {
36465       {
36466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36467       };
36468     } catch (Dali::DaliException e) {
36469       {
36470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36471       };
36472     } catch (...) {
36473       {
36474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36475       };
36476     }
36477   }
36478
36479 }
36480
36481
36482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36483   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36484   Dali::Vector2 *arg2 = 0 ;
36485
36486   arg1 = (Dali::Actor *)jarg1;
36487   arg2 = (Dali::Vector2 *)jarg2;
36488   if (!arg2) {
36489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36490     return ;
36491   }
36492   {
36493     try {
36494       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36495     } catch (std::out_of_range& e) {
36496       {
36497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36498       };
36499     } catch (std::exception& e) {
36500       {
36501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36502       };
36503     } catch (Dali::DaliException e) {
36504       {
36505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36506       };
36507     } catch (...) {
36508       {
36509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36510       };
36511     }
36512   }
36513
36514 }
36515
36516
36517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36518   void * jresult ;
36519   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36520   Dali::Vector2 result;
36521
36522   arg1 = (Dali::Actor *)jarg1;
36523   {
36524     try {
36525       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
36526     } catch (std::out_of_range& e) {
36527       {
36528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36529       };
36530     } catch (std::exception& e) {
36531       {
36532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36533       };
36534     } catch (Dali::DaliException e) {
36535       {
36536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36537       };
36538     } catch (...) {
36539       {
36540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36541       };
36542     }
36543   }
36544
36545   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36546   return jresult;
36547 }
36548
36549
36550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36551   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36552   Dali::Vector2 *arg2 = 0 ;
36553
36554   arg1 = (Dali::Actor *)jarg1;
36555   arg2 = (Dali::Vector2 *)jarg2;
36556   if (!arg2) {
36557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36558     return ;
36559   }
36560   {
36561     try {
36562       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36563     } catch (std::out_of_range& e) {
36564       {
36565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36566       };
36567     } catch (std::exception& e) {
36568       {
36569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36570       };
36571     } catch (Dali::DaliException e) {
36572       {
36573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36574       };
36575     } catch (...) {
36576       {
36577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36578       };
36579     }
36580   }
36581
36582 }
36583
36584
36585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36586   void * jresult ;
36587   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36588   Dali::Vector2 result;
36589
36590   arg1 = (Dali::Actor *)jarg1;
36591   {
36592     try {
36593       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
36594     } catch (std::out_of_range& e) {
36595       {
36596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36597       };
36598     } catch (std::exception& e) {
36599       {
36600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36601       };
36602     } catch (Dali::DaliException e) {
36603       {
36604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36605       };
36606     } catch (...) {
36607       {
36608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36609       };
36610     }
36611   }
36612
36613   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36614   return jresult;
36615 }
36616
36617
36618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36619   int jresult ;
36620   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36621   int result;
36622
36623   arg1 = (Dali::Actor *)jarg1;
36624   {
36625     try {
36626       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
36627       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36628     } catch (std::out_of_range& e) {
36629       {
36630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36631       };
36632     } catch (std::exception& e) {
36633       {
36634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36635       };
36636     } catch (Dali::DaliException e) {
36637       {
36638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36639       };
36640     } catch (...) {
36641       {
36642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36643       };
36644     }
36645   }
36646
36647   jresult = result;
36648   return jresult;
36649 }
36650
36651
36652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36653   unsigned int jresult ;
36654   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36655   Dali::Renderer *arg2 = 0 ;
36656   unsigned int result;
36657
36658   arg1 = (Dali::Actor *)jarg1;
36659   arg2 = (Dali::Renderer *)jarg2;
36660   if (!arg2) {
36661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36662     return 0;
36663   }
36664   {
36665     try {
36666       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36667     } catch (std::out_of_range& e) {
36668       {
36669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36670       };
36671     } catch (std::exception& e) {
36672       {
36673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36674       };
36675     } catch (Dali::DaliException e) {
36676       {
36677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36678       };
36679     } catch (...) {
36680       {
36681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36682       };
36683     }
36684   }
36685
36686   jresult = result;
36687   return jresult;
36688 }
36689
36690
36691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36692   unsigned int jresult ;
36693   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36694   unsigned int result;
36695
36696   arg1 = (Dali::Actor *)jarg1;
36697   {
36698     try {
36699       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36700     } catch (std::out_of_range& e) {
36701       {
36702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36703       };
36704     } catch (std::exception& e) {
36705       {
36706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36707       };
36708     } catch (Dali::DaliException e) {
36709       {
36710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36711       };
36712     } catch (...) {
36713       {
36714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36715       };
36716     }
36717   }
36718
36719   jresult = result;
36720   return jresult;
36721 }
36722
36723
36724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36725   void * jresult ;
36726   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36727   unsigned int arg2 ;
36728   Dali::Renderer result;
36729
36730   arg1 = (Dali::Actor *)jarg1;
36731   arg2 = (unsigned int)jarg2;
36732   {
36733     try {
36734       result = (arg1)->GetRendererAt(arg2);
36735     } catch (std::out_of_range& e) {
36736       {
36737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36738       };
36739     } catch (std::exception& e) {
36740       {
36741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36742       };
36743     } catch (Dali::DaliException e) {
36744       {
36745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36746       };
36747     } catch (...) {
36748       {
36749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36750       };
36751     }
36752   }
36753
36754   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36755   return jresult;
36756 }
36757
36758
36759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36760   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36761   Dali::Renderer *arg2 = 0 ;
36762
36763   arg1 = (Dali::Actor *)jarg1;
36764   arg2 = (Dali::Renderer *)jarg2;
36765   if (!arg2) {
36766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36767     return ;
36768   }
36769   {
36770     try {
36771       (arg1)->RemoveRenderer(*arg2);
36772     } catch (std::out_of_range& e) {
36773       {
36774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36775       };
36776     } catch (std::exception& e) {
36777       {
36778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36779       };
36780     } catch (Dali::DaliException e) {
36781       {
36782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36783       };
36784     } catch (...) {
36785       {
36786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36787       };
36788     }
36789   }
36790
36791 }
36792
36793
36794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36795   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36796   unsigned int arg2 ;
36797
36798   arg1 = (Dali::Actor *)jarg1;
36799   arg2 = (unsigned int)jarg2;
36800   {
36801     try {
36802       (arg1)->RemoveRenderer(arg2);
36803     } catch (std::out_of_range& e) {
36804       {
36805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36806       };
36807     } catch (std::exception& e) {
36808       {
36809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36810       };
36811     } catch (Dali::DaliException e) {
36812       {
36813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36814       };
36815     } catch (...) {
36816       {
36817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36818       };
36819     }
36820   }
36821
36822 }
36823
36824
36825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36826   void * jresult ;
36827   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36828   Dali::Actor::TouchEventSignalType *result = 0 ;
36829
36830   arg1 = (Dali::Actor *)jarg1;
36831   {
36832     try {
36833       result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchSignal();
36834     } catch (std::out_of_range& e) {
36835       {
36836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36837       };
36838     } catch (std::exception& e) {
36839       {
36840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36841       };
36842     } catch (Dali::DaliException e) {
36843       {
36844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36845       };
36846     } catch (...) {
36847       {
36848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36849       };
36850     }
36851   }
36852
36853   jresult = (void *)result;
36854   return jresult;
36855 }
36856
36857
36858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36859   void * jresult ;
36860   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36861   Dali::Actor::HoverSignalType *result = 0 ;
36862
36863   arg1 = (Dali::Actor *)jarg1;
36864   {
36865     try {
36866       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36867     } catch (std::out_of_range& e) {
36868       {
36869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36870       };
36871     } catch (std::exception& e) {
36872       {
36873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36874       };
36875     } catch (Dali::DaliException e) {
36876       {
36877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36878       };
36879     } catch (...) {
36880       {
36881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36882       };
36883     }
36884   }
36885
36886   jresult = (void *)result;
36887   return jresult;
36888 }
36889
36890
36891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36892   void * jresult ;
36893   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36894   Dali::Actor::WheelEventSignalType *result = 0 ;
36895
36896   arg1 = (Dali::Actor *)jarg1;
36897   {
36898     try {
36899       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36900     } catch (std::out_of_range& e) {
36901       {
36902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36903       };
36904     } catch (std::exception& e) {
36905       {
36906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36907       };
36908     } catch (Dali::DaliException e) {
36909       {
36910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36911       };
36912     } catch (...) {
36913       {
36914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36915       };
36916     }
36917   }
36918
36919   jresult = (void *)result;
36920   return jresult;
36921 }
36922
36923
36924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
36925   void * jresult ;
36926   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36927   Dali::Actor::OnSceneSignalType *result = 0 ;
36928
36929   arg1 = (Dali::Actor *)jarg1;
36930   {
36931     try {
36932       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
36933     } catch (std::out_of_range& e) {
36934       {
36935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36936       };
36937     } catch (std::exception& e) {
36938       {
36939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36940       };
36941     } catch (Dali::DaliException e) {
36942       {
36943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36944       };
36945     } catch (...) {
36946       {
36947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36948       };
36949     }
36950   }
36951
36952   jresult = (void *)result;
36953   return jresult;
36954 }
36955
36956
36957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
36958   void * jresult ;
36959   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36960   Dali::Actor::OffSceneSignalType *result = 0 ;
36961
36962   arg1 = (Dali::Actor *)jarg1;
36963   {
36964     try {
36965       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
36966     } catch (std::out_of_range& e) {
36967       {
36968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36969       };
36970     } catch (std::exception& e) {
36971       {
36972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36973       };
36974     } catch (Dali::DaliException e) {
36975       {
36976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36977       };
36978     } catch (...) {
36979       {
36980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36981       };
36982     }
36983   }
36984
36985   jresult = (void *)result;
36986   return jresult;
36987 }
36988
36989
36990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
36991   void * jresult ;
36992   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36993   Dali::Actor::OnRelayoutSignalType *result = 0 ;
36994
36995   arg1 = (Dali::Actor *)jarg1;
36996   {
36997     try {
36998       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
36999     } catch (std::out_of_range& e) {
37000       {
37001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37002       };
37003     } catch (std::exception& e) {
37004       {
37005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37006       };
37007     } catch (Dali::DaliException e) {
37008       {
37009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37010       };
37011     } catch (...) {
37012       {
37013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37014       };
37015     }
37016   }
37017
37018   jresult = (void *)result;
37019   return jresult;
37020 }
37021
37022
37023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37024   Dali::Actor *arg1 = 0 ;
37025
37026   arg1 = (Dali::Actor *)jarg1;
37027   if (!arg1) {
37028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37029     return ;
37030   }
37031   {
37032     try {
37033       Dali::UnparentAndReset(*arg1);
37034     } catch (std::out_of_range& e) {
37035       {
37036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37037       };
37038     } catch (std::exception& e) {
37039       {
37040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37041       };
37042     } catch (Dali::DaliException e) {
37043       {
37044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37045       };
37046     } catch (...) {
37047       {
37048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37049       };
37050     }
37051   }
37052
37053 }
37054
37055
37056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37057   int jresult ;
37058   int result;
37059
37060   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37061   jresult = (int)result;
37062   return jresult;
37063 }
37064
37065
37066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37067   int jresult ;
37068   int result;
37069
37070   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37071   jresult = (int)result;
37072   return jresult;
37073 }
37074
37075
37076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37077   int jresult ;
37078   int result;
37079
37080   result = (int)Dali::Layer::Property::BEHAVIOR;
37081   jresult = (int)result;
37082   return jresult;
37083 }
37084
37085
37086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37087   void * jresult ;
37088   Dali::Layer::Property *result = 0 ;
37089
37090   {
37091     try {
37092       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37093     } catch (std::out_of_range& e) {
37094       {
37095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37096       };
37097     } catch (std::exception& e) {
37098       {
37099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37100       };
37101     } catch (Dali::DaliException e) {
37102       {
37103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37104       };
37105     } catch (...) {
37106       {
37107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37108       };
37109     }
37110   }
37111
37112   jresult = (void *)result;
37113   return jresult;
37114 }
37115
37116
37117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37118   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37119
37120   arg1 = (Dali::Layer::Property *)jarg1;
37121   {
37122     try {
37123       delete arg1;
37124     } catch (std::out_of_range& e) {
37125       {
37126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37127       };
37128     } catch (std::exception& e) {
37129       {
37130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37131       };
37132     } catch (Dali::DaliException e) {
37133       {
37134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37135       };
37136     } catch (...) {
37137       {
37138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37139       };
37140     }
37141   }
37142
37143 }
37144
37145
37146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37147   void * jresult ;
37148   Dali::Layer *result = 0 ;
37149
37150   {
37151     try {
37152       result = (Dali::Layer *)new Dali::Layer();
37153     } catch (std::out_of_range& e) {
37154       {
37155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37156       };
37157     } catch (std::exception& e) {
37158       {
37159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37160       };
37161     } catch (Dali::DaliException e) {
37162       {
37163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37164       };
37165     } catch (...) {
37166       {
37167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37168       };
37169     }
37170   }
37171
37172   jresult = (void *)result;
37173   return jresult;
37174 }
37175
37176
37177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37178   void * jresult ;
37179   Dali::Layer result;
37180
37181   {
37182     try {
37183       result = Dali::Layer::New();
37184     } catch (std::out_of_range& e) {
37185       {
37186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37187       };
37188     } catch (std::exception& e) {
37189       {
37190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37191       };
37192     } catch (Dali::DaliException e) {
37193       {
37194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37195       };
37196     } catch (...) {
37197       {
37198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37199       };
37200     }
37201   }
37202
37203   jresult = new Dali::Layer((const Dali::Layer &)result);
37204   return jresult;
37205 }
37206
37207
37208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37209   void * jresult ;
37210   Dali::BaseHandle arg1 ;
37211   Dali::BaseHandle *argp1 ;
37212   Dali::Layer result;
37213
37214   argp1 = (Dali::BaseHandle *)jarg1;
37215   if (!argp1) {
37216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37217     return 0;
37218   }
37219   arg1 = *argp1;
37220   {
37221     try {
37222       result = Dali::Layer::DownCast(arg1);
37223     } catch (std::out_of_range& e) {
37224       {
37225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37226       };
37227     } catch (std::exception& e) {
37228       {
37229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37230       };
37231     } catch (Dali::DaliException e) {
37232       {
37233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37234       };
37235     } catch (...) {
37236       {
37237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37238       };
37239     }
37240   }
37241
37242   jresult = new Dali::Layer((const Dali::Layer &)result);
37243   return jresult;
37244 }
37245
37246
37247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37248   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37249
37250   arg1 = (Dali::Layer *)jarg1;
37251   {
37252     try {
37253       delete arg1;
37254     } catch (std::out_of_range& e) {
37255       {
37256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37257       };
37258     } catch (std::exception& e) {
37259       {
37260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37261       };
37262     } catch (Dali::DaliException e) {
37263       {
37264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37265       };
37266     } catch (...) {
37267       {
37268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37269       };
37270     }
37271   }
37272
37273 }
37274
37275
37276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37277   void * jresult ;
37278   Dali::Layer *arg1 = 0 ;
37279   Dali::Layer *result = 0 ;
37280
37281   arg1 = (Dali::Layer *)jarg1;
37282   if (!arg1) {
37283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37284     return 0;
37285   }
37286   {
37287     try {
37288       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37289     } catch (std::out_of_range& e) {
37290       {
37291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37292       };
37293     } catch (std::exception& e) {
37294       {
37295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37296       };
37297     } catch (Dali::DaliException e) {
37298       {
37299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37300       };
37301     } catch (...) {
37302       {
37303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37304       };
37305     }
37306   }
37307
37308   jresult = (void *)result;
37309   return jresult;
37310 }
37311
37312
37313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37314   void * jresult ;
37315   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37316   Dali::Layer *arg2 = 0 ;
37317   Dali::Layer *result = 0 ;
37318
37319   arg1 = (Dali::Layer *)jarg1;
37320   arg2 = (Dali::Layer *)jarg2;
37321   if (!arg2) {
37322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37323     return 0;
37324   }
37325   {
37326     try {
37327       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37328     } catch (std::out_of_range& e) {
37329       {
37330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37331       };
37332     } catch (std::exception& e) {
37333       {
37334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37335       };
37336     } catch (Dali::DaliException e) {
37337       {
37338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37339       };
37340     } catch (...) {
37341       {
37342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37343       };
37344     }
37345   }
37346
37347   jresult = (void *)result;
37348   return jresult;
37349 }
37350
37351
37352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37353   unsigned int jresult ;
37354   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37355   unsigned int result;
37356
37357   arg1 = (Dali::Layer *)jarg1;
37358   {
37359     try {
37360       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
37361     } catch (std::out_of_range& e) {
37362       {
37363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37364       };
37365     } catch (std::exception& e) {
37366       {
37367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37368       };
37369     } catch (Dali::DaliException e) {
37370       {
37371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37372       };
37373     } catch (...) {
37374       {
37375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37376       };
37377     }
37378   }
37379
37380   jresult = result;
37381   return jresult;
37382 }
37383
37384
37385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37386   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37387
37388   arg1 = (Dali::Layer *)jarg1;
37389   {
37390     try {
37391       (arg1)->Raise();
37392     } catch (std::out_of_range& e) {
37393       {
37394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37395       };
37396     } catch (std::exception& e) {
37397       {
37398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37399       };
37400     } catch (Dali::DaliException e) {
37401       {
37402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37403       };
37404     } catch (...) {
37405       {
37406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37407       };
37408     }
37409   }
37410
37411 }
37412
37413
37414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37415   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37416
37417   arg1 = (Dali::Layer *)jarg1;
37418   {
37419     try {
37420       (arg1)->Lower();
37421     } catch (std::out_of_range& e) {
37422       {
37423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37424       };
37425     } catch (std::exception& e) {
37426       {
37427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37428       };
37429     } catch (Dali::DaliException e) {
37430       {
37431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37432       };
37433     } catch (...) {
37434       {
37435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37436       };
37437     }
37438   }
37439
37440 }
37441
37442
37443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37444   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37445   Dali::Layer arg2 ;
37446   Dali::Layer *argp2 ;
37447
37448   arg1 = (Dali::Layer *)jarg1;
37449   argp2 = (Dali::Layer *)jarg2;
37450   if (!argp2) {
37451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37452     return ;
37453   }
37454   arg2 = *argp2;
37455   {
37456     try {
37457       (arg1)->RaiseAbove(arg2);
37458     } catch (std::out_of_range& e) {
37459       {
37460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37461       };
37462     } catch (std::exception& e) {
37463       {
37464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37465       };
37466     } catch (Dali::DaliException e) {
37467       {
37468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37469       };
37470     } catch (...) {
37471       {
37472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37473       };
37474     }
37475   }
37476
37477 }
37478
37479
37480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37481   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37482   Dali::Layer arg2 ;
37483   Dali::Layer *argp2 ;
37484
37485   arg1 = (Dali::Layer *)jarg1;
37486   argp2 = (Dali::Layer *)jarg2;
37487   if (!argp2) {
37488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37489     return ;
37490   }
37491   arg2 = *argp2;
37492   {
37493     try {
37494       (arg1)->LowerBelow(arg2);
37495     } catch (std::out_of_range& e) {
37496       {
37497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37498       };
37499     } catch (std::exception& e) {
37500       {
37501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37502       };
37503     } catch (Dali::DaliException e) {
37504       {
37505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37506       };
37507     } catch (...) {
37508       {
37509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37510       };
37511     }
37512   }
37513
37514 }
37515
37516
37517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37518   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37519
37520   arg1 = (Dali::Layer *)jarg1;
37521   {
37522     try {
37523       (arg1)->RaiseToTop();
37524     } catch (std::out_of_range& e) {
37525       {
37526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37527       };
37528     } catch (std::exception& e) {
37529       {
37530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37531       };
37532     } catch (Dali::DaliException e) {
37533       {
37534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37535       };
37536     } catch (...) {
37537       {
37538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37539       };
37540     }
37541   }
37542
37543 }
37544
37545
37546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37547   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37548
37549   arg1 = (Dali::Layer *)jarg1;
37550   {
37551     try {
37552       (arg1)->LowerToBottom();
37553     } catch (std::out_of_range& e) {
37554       {
37555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37556       };
37557     } catch (std::exception& e) {
37558       {
37559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37560       };
37561     } catch (Dali::DaliException e) {
37562       {
37563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37564       };
37565     } catch (...) {
37566       {
37567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37568       };
37569     }
37570   }
37571
37572 }
37573
37574
37575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37576   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37577   Dali::Layer arg2 ;
37578   Dali::Layer *argp2 ;
37579
37580   arg1 = (Dali::Layer *)jarg1;
37581   argp2 = (Dali::Layer *)jarg2;
37582   if (!argp2) {
37583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37584     return ;
37585   }
37586   arg2 = *argp2;
37587   {
37588     try {
37589       (arg1)->MoveAbove(arg2);
37590     } catch (std::out_of_range& e) {
37591       {
37592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37593       };
37594     } catch (std::exception& e) {
37595       {
37596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37597       };
37598     } catch (Dali::DaliException e) {
37599       {
37600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37601       };
37602     } catch (...) {
37603       {
37604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37605       };
37606     }
37607   }
37608
37609 }
37610
37611
37612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37613   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37614   Dali::Layer arg2 ;
37615   Dali::Layer *argp2 ;
37616
37617   arg1 = (Dali::Layer *)jarg1;
37618   argp2 = (Dali::Layer *)jarg2;
37619   if (!argp2) {
37620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37621     return ;
37622   }
37623   arg2 = *argp2;
37624   {
37625     try {
37626       (arg1)->MoveBelow(arg2);
37627     } catch (std::out_of_range& e) {
37628       {
37629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37630       };
37631     } catch (std::exception& e) {
37632       {
37633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37634       };
37635     } catch (Dali::DaliException e) {
37636       {
37637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37638       };
37639     } catch (...) {
37640       {
37641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37642       };
37643     }
37644   }
37645
37646 }
37647
37648
37649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37650   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37651   Dali::Layer::Behavior arg2 ;
37652
37653   arg1 = (Dali::Layer *)jarg1;
37654   arg2 = (Dali::Layer::Behavior)jarg2;
37655   {
37656     try {
37657       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
37658     } catch (std::out_of_range& e) {
37659       {
37660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37661       };
37662     } catch (std::exception& e) {
37663       {
37664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37665       };
37666     } catch (Dali::DaliException e) {
37667       {
37668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37669       };
37670     } catch (...) {
37671       {
37672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37673       };
37674     }
37675   }
37676
37677 }
37678
37679
37680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37681   int jresult ;
37682   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37683   Dali::Layer::Behavior result;
37684
37685   arg1 = (Dali::Layer *)jarg1;
37686   {
37687     try {
37688       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
37689     } catch (std::out_of_range& e) {
37690       {
37691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37692       };
37693     } catch (std::exception& e) {
37694       {
37695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37696       };
37697     } catch (Dali::DaliException e) {
37698       {
37699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37700       };
37701     } catch (...) {
37702       {
37703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37704       };
37705     }
37706   }
37707
37708   jresult = (int)result;
37709   return jresult;
37710 }
37711
37712
37713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37714   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37715   bool arg2 ;
37716
37717   arg1 = (Dali::Layer *)jarg1;
37718   arg2 = jarg2 ? true : false;
37719   {
37720     try {
37721       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
37722     } catch (std::out_of_range& e) {
37723       {
37724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37725       };
37726     } catch (std::exception& e) {
37727       {
37728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37729       };
37730     } catch (Dali::DaliException e) {
37731       {
37732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37733       };
37734     } catch (...) {
37735       {
37736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37737       };
37738     }
37739   }
37740
37741 }
37742
37743
37744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37745   unsigned int jresult ;
37746   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37747   bool result;
37748
37749   arg1 = (Dali::Layer *)jarg1;
37750   {
37751     try {
37752       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
37753     } catch (std::out_of_range& e) {
37754       {
37755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37756       };
37757     } catch (std::exception& e) {
37758       {
37759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37760       };
37761     } catch (Dali::DaliException e) {
37762       {
37763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37764       };
37765     } catch (...) {
37766       {
37767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37768       };
37769     }
37770   }
37771
37772   jresult = result;
37773   return jresult;
37774 }
37775
37776
37777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37778   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37779   int arg2 ;
37780   int arg3 ;
37781   int arg4 ;
37782   int arg5 ;
37783
37784   arg1 = (Dali::Layer *)jarg1;
37785   arg2 = (int)jarg2;
37786   arg3 = (int)jarg3;
37787   arg4 = (int)jarg4;
37788   arg5 = (int)jarg5;
37789   {
37790     try {
37791       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
37792     } catch (std::out_of_range& e) {
37793       {
37794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37795       };
37796     } catch (std::exception& e) {
37797       {
37798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37799       };
37800     } catch (Dali::DaliException e) {
37801       {
37802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37803       };
37804     } catch (...) {
37805       {
37806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37807       };
37808     }
37809   }
37810
37811 }
37812
37813
37814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37815   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37816   Dali::ClippingBox arg2 ;
37817   Dali::ClippingBox *argp2 ;
37818
37819   arg1 = (Dali::Layer *)jarg1;
37820   argp2 = (Dali::ClippingBox *)jarg2;
37821   if (!argp2) {
37822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37823     return ;
37824   }
37825   arg2 = *argp2;
37826   {
37827     try {
37828       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
37829     } catch (std::out_of_range& e) {
37830       {
37831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37832       };
37833     } catch (std::exception& e) {
37834       {
37835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37836       };
37837     } catch (Dali::DaliException e) {
37838       {
37839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37840       };
37841     } catch (...) {
37842       {
37843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37844       };
37845     }
37846   }
37847
37848 }
37849
37850
37851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37852   void * jresult ;
37853   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37854   Dali::ClippingBox result;
37855
37856   arg1 = (Dali::Layer *)jarg1;
37857   {
37858     try {
37859       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
37860     } catch (std::out_of_range& e) {
37861       {
37862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37863       };
37864     } catch (std::exception& e) {
37865       {
37866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37867       };
37868     } catch (Dali::DaliException e) {
37869       {
37870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37871       };
37872     } catch (...) {
37873       {
37874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37875       };
37876     }
37877   }
37878
37879   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37880   return jresult;
37881 }
37882
37883
37884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37885   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37886   bool arg2 ;
37887
37888   arg1 = (Dali::Layer *)jarg1;
37889   arg2 = jarg2 ? true : false;
37890   {
37891     try {
37892       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
37893     } catch (std::out_of_range& e) {
37894       {
37895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37896       };
37897     } catch (std::exception& e) {
37898       {
37899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37900       };
37901     } catch (Dali::DaliException e) {
37902       {
37903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37904       };
37905     } catch (...) {
37906       {
37907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37908       };
37909     }
37910   }
37911
37912 }
37913
37914
37915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37916   unsigned int jresult ;
37917   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37918   bool result;
37919
37920   arg1 = (Dali::Layer *)jarg1;
37921   {
37922     try {
37923       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
37924     } catch (std::out_of_range& e) {
37925       {
37926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37927       };
37928     } catch (std::exception& e) {
37929       {
37930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37931       };
37932     } catch (Dali::DaliException e) {
37933       {
37934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37935       };
37936     } catch (...) {
37937       {
37938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37939       };
37940     }
37941   }
37942
37943   jresult = result;
37944   return jresult;
37945 }
37946
37947
37948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
37949   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37950   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
37951
37952   arg1 = (Dali::Layer *)jarg1;
37953   arg2 = (Dali::Layer::SortFunctionType)jarg2;
37954   {
37955     try {
37956       (arg1)->SetSortFunction(arg2);
37957     } catch (std::out_of_range& e) {
37958       {
37959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37960       };
37961     } catch (std::exception& e) {
37962       {
37963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37964       };
37965     } catch (Dali::DaliException e) {
37966       {
37967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37968       };
37969     } catch (...) {
37970       {
37971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37972       };
37973     }
37974   }
37975
37976 }
37977
37978
37979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
37980   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37981   bool arg2 ;
37982
37983   arg1 = (Dali::Layer *)jarg1;
37984   arg2 = jarg2 ? true : false;
37985   {
37986     try {
37987       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
37988     } catch (std::out_of_range& e) {
37989       {
37990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37991       };
37992     } catch (std::exception& e) {
37993       {
37994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37995       };
37996     } catch (Dali::DaliException e) {
37997       {
37998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37999       };
38000     } catch (...) {
38001       {
38002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38003       };
38004     }
38005   }
38006
38007 }
38008
38009
38010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38011   unsigned int jresult ;
38012   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38013   bool result;
38014
38015   arg1 = (Dali::Layer *)jarg1;
38016   {
38017     try {
38018       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
38019     } catch (std::out_of_range& e) {
38020       {
38021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38022       };
38023     } catch (std::exception& e) {
38024       {
38025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38026       };
38027     } catch (Dali::DaliException e) {
38028       {
38029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38030       };
38031     } catch (...) {
38032       {
38033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38034       };
38035     }
38036   }
38037
38038   jresult = result;
38039   return jresult;
38040 }
38041
38042
38043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38044   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38045   bool arg2 ;
38046
38047   arg1 = (Dali::Layer *)jarg1;
38048   arg2 = jarg2 ? true : false;
38049   {
38050     try {
38051       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
38052     } catch (std::out_of_range& e) {
38053       {
38054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38055       };
38056     } catch (std::exception& e) {
38057       {
38058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38059       };
38060     } catch (Dali::DaliException e) {
38061       {
38062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38063       };
38064     } catch (...) {
38065       {
38066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38067       };
38068     }
38069   }
38070
38071 }
38072
38073
38074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38075   unsigned int jresult ;
38076   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38077   bool result;
38078
38079   arg1 = (Dali::Layer *)jarg1;
38080   {
38081     try {
38082       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
38083     } catch (std::out_of_range& e) {
38084       {
38085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38086       };
38087     } catch (std::exception& e) {
38088       {
38089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38090       };
38091     } catch (Dali::DaliException e) {
38092       {
38093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38094       };
38095     } catch (...) {
38096       {
38097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38098       };
38099     }
38100   }
38101
38102   jresult = result;
38103   return jresult;
38104 }
38105
38106
38107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38108   void * jresult ;
38109   Dali::Stage result;
38110
38111   {
38112     try {
38113       result = Dali::Stage::GetCurrent();
38114     } catch (std::out_of_range& e) {
38115       {
38116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38117       };
38118     } catch (std::exception& e) {
38119       {
38120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38121       };
38122     } catch (Dali::DaliException e) {
38123       {
38124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38125       };
38126     } catch (...) {
38127       {
38128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38129       };
38130     }
38131   }
38132
38133   jresult = new Dali::Stage((const Dali::Stage &)result);
38134   return jresult;
38135 }
38136
38137
38138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38139   unsigned int jresult ;
38140   bool result;
38141
38142   {
38143     try {
38144       result = (bool)Dali::Stage::IsInstalled();
38145     } catch (std::out_of_range& e) {
38146       {
38147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38148       };
38149     } catch (std::exception& e) {
38150       {
38151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38152       };
38153     } catch (Dali::DaliException e) {
38154       {
38155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38156       };
38157     } catch (...) {
38158       {
38159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38160       };
38161     }
38162   }
38163
38164   jresult = result;
38165   return jresult;
38166 }
38167
38168
38169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38170   void * jresult ;
38171   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38172   Dali::Vector2 result;
38173
38174   arg1 = (Dali::Stage *)jarg1;
38175   {
38176     try {
38177       result = ((Dali::Stage const *)arg1)->GetDpi();
38178     } catch (std::out_of_range& e) {
38179       {
38180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38181       };
38182     } catch (std::exception& e) {
38183       {
38184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38185       };
38186     } catch (Dali::DaliException e) {
38187       {
38188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38189       };
38190     } catch (...) {
38191       {
38192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38193       };
38194     }
38195   }
38196
38197   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38198   return jresult;
38199 }
38200
38201
38202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38203   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38204   float arg2 ;
38205
38206   arg1 = (Dali::Stage *)jarg1;
38207   arg2 = (float)jarg2;
38208   {
38209     try {
38210       (arg1)->KeepRendering(arg2);
38211     } catch (std::out_of_range& e) {
38212       {
38213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38214       };
38215     } catch (std::exception& e) {
38216       {
38217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38218       };
38219     } catch (Dali::DaliException e) {
38220       {
38221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38222       };
38223     } catch (...) {
38224       {
38225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38226       };
38227     }
38228   }
38229
38230 }
38231
38232
38233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38234   void * jresult ;
38235   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38236   Dali::Stage::KeyEventSignalType *result = 0 ;
38237
38238   arg1 = (Dali::Stage *)jarg1;
38239   {
38240     try {
38241       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38242     } catch (std::out_of_range& e) {
38243       {
38244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38245       };
38246     } catch (std::exception& e) {
38247       {
38248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38249       };
38250     } catch (Dali::DaliException e) {
38251       {
38252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38253       };
38254     } catch (...) {
38255       {
38256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38257       };
38258     }
38259   }
38260
38261   jresult = (void *)result;
38262   return jresult;
38263 }
38264
38265
38266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38267   void * jresult ;
38268   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38269   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38270
38271   arg1 = (Dali::Stage *)jarg1;
38272   {
38273     try {
38274       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38275     } catch (std::out_of_range& e) {
38276       {
38277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38278       };
38279     } catch (std::exception& e) {
38280       {
38281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38282       };
38283     } catch (Dali::DaliException e) {
38284       {
38285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38286       };
38287     } catch (...) {
38288       {
38289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38290       };
38291     }
38292   }
38293
38294   jresult = (void *)result;
38295   return jresult;
38296 }
38297
38298
38299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38300   void * jresult ;
38301   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38302   Dali::Stage::TouchSignalType *result = 0 ;
38303
38304   arg1 = (Dali::Stage *)jarg1;
38305   {
38306     try {
38307       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38308     } catch (std::out_of_range& e) {
38309       {
38310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38311       };
38312     } catch (std::exception& e) {
38313       {
38314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38315       };
38316     } catch (Dali::DaliException e) {
38317       {
38318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38319       };
38320     } catch (...) {
38321       {
38322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38323       };
38324     }
38325   }
38326
38327   jresult = (void *)result;
38328   return jresult;
38329 }
38330
38331
38332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38333   void * jresult ;
38334   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38335   Dali::Stage::WheelEventSignalType *result = 0 ;
38336
38337   arg1 = (Dali::Stage *)jarg1;
38338   {
38339     try {
38340       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38341     } catch (std::out_of_range& e) {
38342       {
38343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38344       };
38345     } catch (std::exception& e) {
38346       {
38347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38348       };
38349     } catch (Dali::DaliException e) {
38350       {
38351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38352       };
38353     } catch (...) {
38354       {
38355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38356       };
38357     }
38358   }
38359
38360   jresult = (void *)result;
38361   return jresult;
38362 }
38363
38364
38365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38366   void * jresult ;
38367   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38368   Dali::Stage::ContextStatusSignal *result = 0 ;
38369
38370   arg1 = (Dali::Stage *)jarg1;
38371   {
38372     try {
38373       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38374     } catch (std::out_of_range& e) {
38375       {
38376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38377       };
38378     } catch (std::exception& e) {
38379       {
38380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38381       };
38382     } catch (Dali::DaliException e) {
38383       {
38384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38385       };
38386     } catch (...) {
38387       {
38388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38389       };
38390     }
38391   }
38392
38393   jresult = (void *)result;
38394   return jresult;
38395 }
38396
38397
38398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38399   void * jresult ;
38400   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38401   Dali::Stage::ContextStatusSignal *result = 0 ;
38402
38403   arg1 = (Dali::Stage *)jarg1;
38404   {
38405     try {
38406       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38407     } catch (std::out_of_range& e) {
38408       {
38409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38410       };
38411     } catch (std::exception& e) {
38412       {
38413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38414       };
38415     } catch (Dali::DaliException e) {
38416       {
38417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38418       };
38419     } catch (...) {
38420       {
38421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38422       };
38423     }
38424   }
38425
38426   jresult = (void *)result;
38427   return jresult;
38428 }
38429
38430
38431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38432   void * jresult ;
38433   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38434   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38435
38436   arg1 = (Dali::Stage *)jarg1;
38437   {
38438     try {
38439       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
38440     } catch (std::out_of_range& e) {
38441       {
38442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38443       };
38444     } catch (std::exception& e) {
38445       {
38446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38447       };
38448     } catch (Dali::DaliException e) {
38449       {
38450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38451       };
38452     } catch (...) {
38453       {
38454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38455       };
38456     }
38457   }
38458
38459   jresult = (void *)result;
38460   return jresult;
38461 }
38462
38463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
38464   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38465   Dali::DevelStage::Rendering arg2 ;
38466
38467   arg1 = (Dali::Stage *)jarg1;
38468   arg2 = (Dali::DevelStage::Rendering)jarg2;
38469   {
38470     try {
38471       DevelStage::SetRenderingBehavior(*arg1,arg2);
38472     } catch (std::out_of_range& e) {
38473       {
38474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38475       };
38476     } catch (std::exception& e) {
38477       {
38478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38479       };
38480     } catch (Dali::DaliException e) {
38481       {
38482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38483       };
38484     } catch (...) {
38485       {
38486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38487       };
38488     }
38489   }
38490
38491 }
38492
38493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
38494
38495   int jresult ;
38496   int result ;
38497   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38498
38499   arg1 = (Dali::Stage *)jarg1;
38500   {
38501     try {
38502       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
38503     } catch (std::out_of_range& e) {
38504       {
38505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38506       };
38507     } catch (std::exception& e) {
38508       {
38509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38510       };
38511     } catch (Dali::DaliException e) {
38512       {
38513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38514       };
38515     } catch (...) {
38516       {
38517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38518       };
38519     }
38520   }
38521
38522   jresult = result;
38523   return jresult;
38524 }
38525
38526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
38527   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38528
38529   arg1 = (Dali::RelayoutContainer *)jarg1;
38530   {
38531     try {
38532       delete arg1;
38533     } catch (std::out_of_range& e) {
38534       {
38535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38536       };
38537     } catch (std::exception& e) {
38538       {
38539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38540       };
38541     } catch (Dali::DaliException e) {
38542       {
38543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38544       };
38545     } catch (...) {
38546       {
38547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38548       };
38549     }
38550   }
38551
38552 }
38553
38554
38555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
38556   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38557   Dali::Actor *arg2 = 0 ;
38558   Dali::Vector2 *arg3 = 0 ;
38559
38560   arg1 = (Dali::RelayoutContainer *)jarg1;
38561   arg2 = (Dali::Actor *)jarg2;
38562   if (!arg2) {
38563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38564     return ;
38565   }
38566   arg3 = (Dali::Vector2 *)jarg3;
38567   if (!arg3) {
38568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38569     return ;
38570   }
38571   {
38572     try {
38573       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
38574     } catch (std::out_of_range& e) {
38575       {
38576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38577       };
38578     } catch (std::exception& e) {
38579       {
38580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38581       };
38582     } catch (Dali::DaliException e) {
38583       {
38584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38585       };
38586     } catch (...) {
38587       {
38588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38589       };
38590     }
38591   }
38592
38593 }
38594
38595
38596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
38597   void * jresult ;
38598   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38599   Dali::CustomActor result;
38600
38601   arg1 = (Dali::CustomActorImpl *)jarg1;
38602   {
38603     try {
38604       result = ((Dali::CustomActorImpl const *)arg1)->Self();
38605     } catch (std::out_of_range& e) {
38606       {
38607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38608       };
38609     } catch (std::exception& e) {
38610       {
38611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38612       };
38613     } catch (Dali::DaliException e) {
38614       {
38615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38616       };
38617     } catch (...) {
38618       {
38619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38620       };
38621     }
38622   }
38623
38624   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
38625   return jresult;
38626 }
38627
38628
38629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
38630   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38631   int arg2 ;
38632
38633   arg1 = (Dali::CustomActorImpl *)jarg1;
38634   arg2 = (int)jarg2;
38635   {
38636     try {
38637       (arg1)->OnSceneConnection(arg2);
38638     } catch (std::out_of_range& e) {
38639       {
38640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38641       };
38642     } catch (std::exception& e) {
38643       {
38644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38645       };
38646     } catch (Dali::DaliException e) {
38647       {
38648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38649       };
38650     } catch (...) {
38651       {
38652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38653       };
38654     }
38655   }
38656
38657 }
38658
38659
38660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
38661   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38662
38663   arg1 = (Dali::CustomActorImpl *)jarg1;
38664   {
38665     try {
38666       (arg1)->OnSceneDisconnection();
38667     } catch (std::out_of_range& e) {
38668       {
38669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38670       };
38671     } catch (std::exception& e) {
38672       {
38673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38674       };
38675     } catch (Dali::DaliException e) {
38676       {
38677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38678       };
38679     } catch (...) {
38680       {
38681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38682       };
38683     }
38684   }
38685
38686 }
38687
38688
38689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
38690   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38691   Dali::Actor *arg2 = 0 ;
38692
38693   arg1 = (Dali::CustomActorImpl *)jarg1;
38694   arg2 = (Dali::Actor *)jarg2;
38695   if (!arg2) {
38696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38697     return ;
38698   }
38699   {
38700     try {
38701       (arg1)->OnChildAdd(*arg2);
38702     } catch (std::out_of_range& e) {
38703       {
38704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38705       };
38706     } catch (std::exception& e) {
38707       {
38708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38709       };
38710     } catch (Dali::DaliException e) {
38711       {
38712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38713       };
38714     } catch (...) {
38715       {
38716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38717       };
38718     }
38719   }
38720
38721 }
38722
38723
38724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
38725   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38726   Dali::Actor *arg2 = 0 ;
38727
38728   arg1 = (Dali::CustomActorImpl *)jarg1;
38729   arg2 = (Dali::Actor *)jarg2;
38730   if (!arg2) {
38731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38732     return ;
38733   }
38734   {
38735     try {
38736       (arg1)->OnChildRemove(*arg2);
38737     } catch (std::out_of_range& e) {
38738       {
38739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38740       };
38741     } catch (std::exception& e) {
38742       {
38743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38744       };
38745     } catch (Dali::DaliException e) {
38746       {
38747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38748       };
38749     } catch (...) {
38750       {
38751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38752       };
38753     }
38754   }
38755
38756 }
38757
38758
38759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
38760   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38761   Dali::Property::Index arg2 ;
38762   Dali::Property::Value arg3 ;
38763   Dali::Property::Value *argp3 ;
38764
38765   arg1 = (Dali::CustomActorImpl *)jarg1;
38766   arg2 = (Dali::Property::Index)jarg2;
38767   argp3 = (Dali::Property::Value *)jarg3;
38768   if (!argp3) {
38769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
38770     return ;
38771   }
38772   arg3 = *argp3;
38773   {
38774     try {
38775       (arg1)->OnPropertySet(arg2,arg3);
38776     } catch (std::out_of_range& e) {
38777       {
38778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38779       };
38780     } catch (std::exception& e) {
38781       {
38782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38783       };
38784     } catch (Dali::DaliException e) {
38785       {
38786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38787       };
38788     } catch (...) {
38789       {
38790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38791       };
38792     }
38793   }
38794
38795 }
38796
38797
38798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
38799   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38800   Dali::Vector3 *arg2 = 0 ;
38801
38802   arg1 = (Dali::CustomActorImpl *)jarg1;
38803   arg2 = (Dali::Vector3 *)jarg2;
38804   if (!arg2) {
38805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38806     return ;
38807   }
38808   {
38809     try {
38810       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
38811     } catch (std::out_of_range& e) {
38812       {
38813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38814       };
38815     } catch (std::exception& e) {
38816       {
38817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38818       };
38819     } catch (Dali::DaliException e) {
38820       {
38821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38822       };
38823     } catch (...) {
38824       {
38825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38826       };
38827     }
38828   }
38829
38830 }
38831
38832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
38833   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38834   Dali::Animation *arg2 = 0 ;
38835   Dali::Vector3 *arg3 = 0 ;
38836
38837   arg1 = (Dali::CustomActorImpl *)jarg1;
38838   arg2 = (Dali::Animation *)jarg2;
38839   if (!arg2) {
38840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
38841     return ;
38842   }
38843   arg3 = (Dali::Vector3 *)jarg3;
38844   if (!arg3) {
38845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38846     return ;
38847   }
38848   {
38849     try {
38850       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
38851     } catch (std::out_of_range& e) {
38852       {
38853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38854       };
38855     } catch (std::exception& e) {
38856       {
38857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38858       };
38859     } catch (Dali::DaliException e) {
38860       {
38861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38862       };
38863     } catch (...) {
38864       {
38865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38866       };
38867     }
38868   }
38869 }
38870
38871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
38872   unsigned int jresult ;
38873   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38874   Dali::HoverEvent *arg2 = 0 ;
38875   bool result;
38876
38877   arg1 = (Dali::CustomActorImpl *)jarg1;
38878   arg2 = (Dali::HoverEvent *)jarg2;
38879   if (!arg2) {
38880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
38881     return 0;
38882   }
38883   {
38884     try {
38885       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
38886     } catch (std::out_of_range& e) {
38887       {
38888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38889       };
38890     } catch (std::exception& e) {
38891       {
38892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38893       };
38894     } catch (Dali::DaliException e) {
38895       {
38896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38897       };
38898     } catch (...) {
38899       {
38900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38901       };
38902     }
38903   }
38904
38905   jresult = result;
38906   return jresult;
38907 }
38908
38909
38910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
38911   unsigned int jresult ;
38912   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38913   Dali::KeyEvent *arg2 = 0 ;
38914   bool result;
38915
38916   arg1 = (Dali::CustomActorImpl *)jarg1;
38917   arg2 = (Dali::KeyEvent *)jarg2;
38918   if (!arg2) {
38919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
38920     return 0;
38921   }
38922   {
38923     try {
38924       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
38925     } catch (std::out_of_range& e) {
38926       {
38927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38928       };
38929     } catch (std::exception& e) {
38930       {
38931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38932       };
38933     } catch (Dali::DaliException e) {
38934       {
38935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38936       };
38937     } catch (...) {
38938       {
38939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38940       };
38941     }
38942   }
38943
38944   jresult = result;
38945   return jresult;
38946 }
38947
38948
38949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
38950   unsigned int jresult ;
38951   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38952   Dali::WheelEvent *arg2 = 0 ;
38953   bool result;
38954
38955   arg1 = (Dali::CustomActorImpl *)jarg1;
38956   arg2 = (Dali::WheelEvent *)jarg2;
38957   if (!arg2) {
38958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
38959     return 0;
38960   }
38961   {
38962     try {
38963       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
38964     } catch (std::out_of_range& e) {
38965       {
38966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38967       };
38968     } catch (std::exception& e) {
38969       {
38970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38971       };
38972     } catch (Dali::DaliException e) {
38973       {
38974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38975       };
38976     } catch (...) {
38977       {
38978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38979       };
38980     }
38981   }
38982
38983   jresult = result;
38984   return jresult;
38985 }
38986
38987
38988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
38989   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38990   Dali::Vector2 *arg2 = 0 ;
38991   Dali::RelayoutContainer *arg3 = 0 ;
38992
38993   arg1 = (Dali::CustomActorImpl *)jarg1;
38994   arg2 = (Dali::Vector2 *)jarg2;
38995   if (!arg2) {
38996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38997     return ;
38998   }
38999   arg3 = (Dali::RelayoutContainer *)jarg3;
39000   if (!arg3) {
39001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39002     return ;
39003   }
39004   {
39005     try {
39006       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39007     } catch (std::out_of_range& e) {
39008       {
39009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39010       };
39011     } catch (std::exception& e) {
39012       {
39013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39014       };
39015     } catch (Dali::DaliException e) {
39016       {
39017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39018       };
39019     } catch (...) {
39020       {
39021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39022       };
39023     }
39024   }
39025
39026 }
39027
39028
39029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39030   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39031   Dali::ResizePolicy::Type arg2 ;
39032   Dali::Dimension::Type arg3 ;
39033
39034   arg1 = (Dali::CustomActorImpl *)jarg1;
39035   arg2 = (Dali::ResizePolicy::Type)jarg2;
39036   arg3 = (Dali::Dimension::Type)jarg3;
39037   {
39038     try {
39039       (arg1)->OnSetResizePolicy(arg2,arg3);
39040     } catch (std::out_of_range& e) {
39041       {
39042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39043       };
39044     } catch (std::exception& e) {
39045       {
39046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39047       };
39048     } catch (Dali::DaliException e) {
39049       {
39050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39051       };
39052     } catch (...) {
39053       {
39054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39055       };
39056     }
39057   }
39058
39059 }
39060
39061
39062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39063   void * jresult ;
39064   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39065   Dali::Vector3 result;
39066
39067   arg1 = (Dali::CustomActorImpl *)jarg1;
39068   {
39069     try {
39070       result = (arg1)->GetNaturalSize();
39071     } catch (std::out_of_range& e) {
39072       {
39073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39074       };
39075     } catch (std::exception& e) {
39076       {
39077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39078       };
39079     } catch (Dali::DaliException e) {
39080       {
39081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39082       };
39083     } catch (...) {
39084       {
39085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39086       };
39087     }
39088   }
39089
39090   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39091   return jresult;
39092 }
39093
39094
39095 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39096   float jresult ;
39097   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39098   Dali::Actor *arg2 = 0 ;
39099   Dali::Dimension::Type arg3 ;
39100   float result;
39101
39102   arg1 = (Dali::CustomActorImpl *)jarg1;
39103   arg2 = (Dali::Actor *)jarg2;
39104   if (!arg2) {
39105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39106     return 0;
39107   }
39108   arg3 = (Dali::Dimension::Type)jarg3;
39109   {
39110     try {
39111       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39112     } catch (std::out_of_range& e) {
39113       {
39114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39115       };
39116     } catch (std::exception& e) {
39117       {
39118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39119       };
39120     } catch (Dali::DaliException e) {
39121       {
39122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39123       };
39124     } catch (...) {
39125       {
39126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39127       };
39128     }
39129   }
39130
39131   jresult = result;
39132   return jresult;
39133 }
39134
39135
39136 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39137   float jresult ;
39138   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39139   float arg2 ;
39140   float result;
39141
39142   arg1 = (Dali::CustomActorImpl *)jarg1;
39143   arg2 = (float)jarg2;
39144   {
39145     try {
39146       result = (float)(arg1)->GetHeightForWidth(arg2);
39147     } catch (std::out_of_range& e) {
39148       {
39149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39150       };
39151     } catch (std::exception& e) {
39152       {
39153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39154       };
39155     } catch (Dali::DaliException e) {
39156       {
39157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39158       };
39159     } catch (...) {
39160       {
39161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39162       };
39163     }
39164   }
39165
39166   jresult = result;
39167   return jresult;
39168 }
39169
39170
39171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39172   float jresult ;
39173   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39174   float arg2 ;
39175   float result;
39176
39177   arg1 = (Dali::CustomActorImpl *)jarg1;
39178   arg2 = (float)jarg2;
39179   {
39180     try {
39181       result = (float)(arg1)->GetWidthForHeight(arg2);
39182     } catch (std::out_of_range& e) {
39183       {
39184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39185       };
39186     } catch (std::exception& e) {
39187       {
39188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39189       };
39190     } catch (Dali::DaliException e) {
39191       {
39192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39193       };
39194     } catch (...) {
39195       {
39196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39197       };
39198     }
39199   }
39200
39201   jresult = result;
39202   return jresult;
39203 }
39204
39205
39206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39207   unsigned int jresult ;
39208   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39209   Dali::Dimension::Type arg2 ;
39210   bool result;
39211
39212   arg1 = (Dali::CustomActorImpl *)jarg1;
39213   arg2 = (Dali::Dimension::Type)jarg2;
39214   {
39215     try {
39216       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39217     } catch (std::out_of_range& e) {
39218       {
39219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39220       };
39221     } catch (std::exception& e) {
39222       {
39223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39224       };
39225     } catch (Dali::DaliException e) {
39226       {
39227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39228       };
39229     } catch (...) {
39230       {
39231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39232       };
39233     }
39234   }
39235
39236   jresult = result;
39237   return jresult;
39238 }
39239
39240
39241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39242   unsigned int jresult ;
39243   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39244   bool result;
39245
39246   arg1 = (Dali::CustomActorImpl *)jarg1;
39247   {
39248     try {
39249       result = (bool)(arg1)->RelayoutDependentOnChildren();
39250     } catch (std::out_of_range& e) {
39251       {
39252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39253       };
39254     } catch (std::exception& e) {
39255       {
39256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39257       };
39258     } catch (Dali::DaliException e) {
39259       {
39260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39261       };
39262     } catch (...) {
39263       {
39264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39265       };
39266     }
39267   }
39268
39269   jresult = result;
39270   return jresult;
39271 }
39272
39273
39274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39275   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39276   Dali::Dimension::Type arg2 ;
39277
39278   arg1 = (Dali::CustomActorImpl *)jarg1;
39279   arg2 = (Dali::Dimension::Type)jarg2;
39280   {
39281     try {
39282       (arg1)->OnCalculateRelayoutSize(arg2);
39283     } catch (std::out_of_range& e) {
39284       {
39285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39286       };
39287     } catch (std::exception& e) {
39288       {
39289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39290       };
39291     } catch (Dali::DaliException e) {
39292       {
39293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39294       };
39295     } catch (...) {
39296       {
39297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39298       };
39299     }
39300   }
39301
39302 }
39303
39304
39305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39306   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39307   float arg2 ;
39308   Dali::Dimension::Type arg3 ;
39309
39310   arg1 = (Dali::CustomActorImpl *)jarg1;
39311   arg2 = (float)jarg2;
39312   arg3 = (Dali::Dimension::Type)jarg3;
39313   {
39314     try {
39315       (arg1)->OnLayoutNegotiated(arg2,arg3);
39316     } catch (std::out_of_range& e) {
39317       {
39318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39319       };
39320     } catch (std::exception& e) {
39321       {
39322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39323       };
39324     } catch (Dali::DaliException e) {
39325       {
39326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39327       };
39328     } catch (...) {
39329       {
39330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39331       };
39332     }
39333   }
39334
39335 }
39336
39337
39338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39339   unsigned int jresult ;
39340   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39341   bool result;
39342
39343   arg1 = (Dali::CustomActorImpl *)jarg1;
39344   {
39345     try {
39346       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39347     } catch (std::out_of_range& e) {
39348       {
39349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39350       };
39351     } catch (std::exception& e) {
39352       {
39353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39354       };
39355     } catch (Dali::DaliException e) {
39356       {
39357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39358       };
39359     } catch (...) {
39360       {
39361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39362       };
39363     }
39364   }
39365
39366   jresult = result;
39367   return jresult;
39368 }
39369
39370
39371 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39372   unsigned int jresult ;
39373   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39374   bool result;
39375
39376   arg1 = (Dali::CustomActorImpl *)jarg1;
39377   {
39378     try {
39379       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39380     } catch (std::out_of_range& e) {
39381       {
39382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39383       };
39384     } catch (std::exception& e) {
39385       {
39386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39387       };
39388     } catch (Dali::DaliException e) {
39389       {
39390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39391       };
39392     } catch (...) {
39393       {
39394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39395       };
39396     }
39397   }
39398
39399   jresult = result;
39400   return jresult;
39401 }
39402
39403
39404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39405   unsigned int jresult ;
39406   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39407   bool result;
39408
39409   arg1 = (Dali::CustomActorImpl *)jarg1;
39410   {
39411     try {
39412       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39413     } catch (std::out_of_range& e) {
39414       {
39415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39416       };
39417     } catch (std::exception& e) {
39418       {
39419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39420       };
39421     } catch (Dali::DaliException e) {
39422       {
39423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39424       };
39425     } catch (...) {
39426       {
39427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39428       };
39429     }
39430   }
39431
39432   jresult = result;
39433   return jresult;
39434 }
39435
39436
39437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
39438   unsigned int jresult ;
39439   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39440   bool result;
39441
39442   arg1 = (Dali::CustomActorImpl *)jarg1;
39443   {
39444     try {
39445       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
39446     } catch (std::out_of_range& e) {
39447       {
39448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39449       };
39450     } catch (std::exception& e) {
39451       {
39452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39453       };
39454     } catch (Dali::DaliException e) {
39455       {
39456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39457       };
39458     } catch (...) {
39459       {
39460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39461       };
39462     }
39463   }
39464
39465   jresult = result;
39466   return jresult;
39467 }
39468
39469
39470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
39471   void * jresult ;
39472   Dali::CustomActor *result = 0 ;
39473
39474   {
39475     try {
39476       result = (Dali::CustomActor *)new Dali::CustomActor();
39477     } catch (std::out_of_range& e) {
39478       {
39479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39480       };
39481     } catch (std::exception& e) {
39482       {
39483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39484       };
39485     } catch (Dali::DaliException e) {
39486       {
39487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39488       };
39489     } catch (...) {
39490       {
39491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39492       };
39493     }
39494   }
39495
39496   jresult = (void *)result;
39497   return jresult;
39498 }
39499
39500
39501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
39502   void * jresult ;
39503   Dali::BaseHandle arg1 ;
39504   Dali::BaseHandle *argp1 ;
39505   Dali::CustomActor result;
39506
39507   argp1 = (Dali::BaseHandle *)jarg1;
39508   if (!argp1) {
39509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39510     return 0;
39511   }
39512   arg1 = *argp1;
39513   {
39514     try {
39515       result = Dali::CustomActor::DownCast(arg1);
39516     } catch (std::out_of_range& e) {
39517       {
39518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39519       };
39520     } catch (std::exception& e) {
39521       {
39522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39523       };
39524     } catch (Dali::DaliException e) {
39525       {
39526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39527       };
39528     } catch (...) {
39529       {
39530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39531       };
39532     }
39533   }
39534
39535   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39536   return jresult;
39537 }
39538
39539
39540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
39541   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39542
39543   arg1 = (Dali::CustomActor *)jarg1;
39544   {
39545     try {
39546       delete arg1;
39547     } catch (std::out_of_range& e) {
39548       {
39549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39550       };
39551     } catch (std::exception& e) {
39552       {
39553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39554       };
39555     } catch (Dali::DaliException e) {
39556       {
39557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39558       };
39559     } catch (...) {
39560       {
39561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39562       };
39563     }
39564   }
39565
39566 }
39567
39568
39569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
39570   void * jresult ;
39571   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39572   Dali::CustomActorImpl *result = 0 ;
39573
39574   arg1 = (Dali::CustomActor *)jarg1;
39575   {
39576     try {
39577       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
39578     } catch (std::out_of_range& e) {
39579       {
39580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39581       };
39582     } catch (std::exception& e) {
39583       {
39584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39585       };
39586     } catch (Dali::DaliException e) {
39587       {
39588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39589       };
39590     } catch (...) {
39591       {
39592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39593       };
39594     }
39595   }
39596
39597   jresult = (void *)result;
39598   return jresult;
39599 }
39600
39601
39602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
39603   void * jresult ;
39604   Dali::CustomActorImpl *arg1 = 0 ;
39605   Dali::CustomActor *result = 0 ;
39606
39607   arg1 = (Dali::CustomActorImpl *)jarg1;
39608   if (!arg1) {
39609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
39610     return 0;
39611   }
39612   {
39613     try {
39614       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
39615     } catch (std::out_of_range& e) {
39616       {
39617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39618       };
39619     } catch (std::exception& e) {
39620       {
39621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39622       };
39623     } catch (Dali::DaliException e) {
39624       {
39625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39626       };
39627     } catch (...) {
39628       {
39629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39630       };
39631     }
39632   }
39633
39634   jresult = (void *)result;
39635   return jresult;
39636 }
39637
39638
39639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
39640   void * jresult ;
39641   Dali::CustomActor *arg1 = 0 ;
39642   Dali::CustomActor *result = 0 ;
39643
39644   arg1 = (Dali::CustomActor *)jarg1;
39645   if (!arg1) {
39646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39647     return 0;
39648   }
39649   {
39650     try {
39651       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
39652     } catch (std::out_of_range& e) {
39653       {
39654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39655       };
39656     } catch (std::exception& e) {
39657       {
39658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39659       };
39660     } catch (Dali::DaliException e) {
39661       {
39662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39663       };
39664     } catch (...) {
39665       {
39666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39667       };
39668     }
39669   }
39670
39671   jresult = (void *)result;
39672   return jresult;
39673 }
39674
39675
39676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
39677   void * jresult ;
39678   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39679   Dali::CustomActor *arg2 = 0 ;
39680   Dali::CustomActor *result = 0 ;
39681
39682   arg1 = (Dali::CustomActor *)jarg1;
39683   arg2 = (Dali::CustomActor *)jarg2;
39684   if (!arg2) {
39685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39686     return 0;
39687   }
39688   {
39689     try {
39690       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
39691     } catch (std::out_of_range& e) {
39692       {
39693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39694       };
39695     } catch (std::exception& e) {
39696       {
39697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39698       };
39699     } catch (Dali::DaliException e) {
39700       {
39701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39702       };
39703     } catch (...) {
39704       {
39705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39706       };
39707     }
39708   }
39709
39710   jresult = (void *)result;
39711   return jresult;
39712 }
39713
39714
39715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
39716   int jresult ;
39717   int result;
39718
39719   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
39720   jresult = (int)result;
39721   return jresult;
39722 }
39723
39724
39725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
39726   int jresult ;
39727   int result;
39728
39729   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
39730   jresult = (int)result;
39731   return jresult;
39732 }
39733
39734
39735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
39736   int jresult ;
39737   int result;
39738
39739   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
39740   jresult = (int)result;
39741   return jresult;
39742 }
39743
39744
39745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
39746   int jresult ;
39747   int result;
39748
39749   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
39750   jresult = (int)result;
39751   return jresult;
39752 }
39753
39754
39755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
39756   int jresult ;
39757   int result;
39758
39759   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
39760   jresult = (int)result;
39761   return jresult;
39762 }
39763
39764
39765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
39766   int jresult ;
39767   int result;
39768
39769   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
39770   jresult = (int)result;
39771   return jresult;
39772 }
39773
39774
39775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
39776   int jresult ;
39777   int result;
39778
39779   result = (int)Dali::PanGestureDetector::Property::PANNING;
39780   jresult = (int)result;
39781   return jresult;
39782 }
39783
39784
39785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
39786   void * jresult ;
39787   Dali::PanGestureDetector::Property *result = 0 ;
39788
39789   {
39790     try {
39791       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
39792     } catch (std::out_of_range& e) {
39793       {
39794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39795       };
39796     } catch (std::exception& e) {
39797       {
39798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39799       };
39800     } catch (Dali::DaliException e) {
39801       {
39802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39803       };
39804     } catch (...) {
39805       {
39806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39807       };
39808     }
39809   }
39810
39811   jresult = (void *)result;
39812   return jresult;
39813 }
39814
39815
39816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
39817   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
39818
39819   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
39820   {
39821     try {
39822       delete arg1;
39823     } catch (std::out_of_range& e) {
39824       {
39825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39826       };
39827     } catch (std::exception& e) {
39828       {
39829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39830       };
39831     } catch (Dali::DaliException e) {
39832       {
39833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39834       };
39835     } catch (...) {
39836       {
39837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39838       };
39839     }
39840   }
39841
39842 }
39843
39844
39845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
39846   void * jresult ;
39847   Dali::Radian *result = 0 ;
39848
39849   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
39850   jresult = (void *)result;
39851   return jresult;
39852 }
39853
39854
39855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
39856   void * jresult ;
39857   Dali::Radian *result = 0 ;
39858
39859   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
39860   jresult = (void *)result;
39861   return jresult;
39862 }
39863
39864
39865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
39866   void * jresult ;
39867   Dali::Radian *result = 0 ;
39868
39869   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
39870   jresult = (void *)result;
39871   return jresult;
39872 }
39873
39874
39875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
39876   void * jresult ;
39877   Dali::Radian *result = 0 ;
39878
39879   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
39880   jresult = (void *)result;
39881   return jresult;
39882 }
39883
39884
39885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
39886   void * jresult ;
39887   Dali::Radian *result = 0 ;
39888
39889   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
39890   jresult = (void *)result;
39891   return jresult;
39892 }
39893
39894
39895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
39896   void * jresult ;
39897   Dali::Radian *result = 0 ;
39898
39899   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
39900   jresult = (void *)result;
39901   return jresult;
39902 }
39903
39904
39905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
39906   void * jresult ;
39907   Dali::Radian *result = 0 ;
39908
39909   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
39910   jresult = (void *)result;
39911   return jresult;
39912 }
39913
39914
39915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
39916   void * jresult ;
39917   Dali::PanGestureDetector *result = 0 ;
39918
39919   {
39920     try {
39921       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
39922     } catch (std::out_of_range& e) {
39923       {
39924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39925       };
39926     } catch (std::exception& e) {
39927       {
39928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39929       };
39930     } catch (Dali::DaliException e) {
39931       {
39932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39933       };
39934     } catch (...) {
39935       {
39936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39937       };
39938     }
39939   }
39940
39941   jresult = (void *)result;
39942   return jresult;
39943 }
39944
39945
39946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
39947   void * jresult ;
39948   Dali::PanGestureDetector result;
39949
39950   {
39951     try {
39952       result = Dali::PanGestureDetector::New();
39953     } catch (std::out_of_range& e) {
39954       {
39955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39956       };
39957     } catch (std::exception& e) {
39958       {
39959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39960       };
39961     } catch (Dali::DaliException e) {
39962       {
39963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39964       };
39965     } catch (...) {
39966       {
39967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39968       };
39969     }
39970   }
39971
39972   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
39973   return jresult;
39974 }
39975
39976
39977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
39978   void * jresult ;
39979   Dali::BaseHandle arg1 ;
39980   Dali::BaseHandle *argp1 ;
39981   Dali::PanGestureDetector result;
39982
39983   argp1 = (Dali::BaseHandle *)jarg1;
39984   if (!argp1) {
39985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39986     return 0;
39987   }
39988   arg1 = *argp1;
39989   {
39990     try {
39991       result = Dali::PanGestureDetector::DownCast(arg1);
39992     } catch (std::out_of_range& e) {
39993       {
39994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39995       };
39996     } catch (std::exception& e) {
39997       {
39998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39999       };
40000     } catch (Dali::DaliException e) {
40001       {
40002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40003       };
40004     } catch (...) {
40005       {
40006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40007       };
40008     }
40009   }
40010
40011   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40012   return jresult;
40013 }
40014
40015
40016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40017   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40018
40019   arg1 = (Dali::PanGestureDetector *)jarg1;
40020   {
40021     try {
40022       delete arg1;
40023     } catch (std::out_of_range& e) {
40024       {
40025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40026       };
40027     } catch (std::exception& e) {
40028       {
40029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40030       };
40031     } catch (Dali::DaliException e) {
40032       {
40033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40034       };
40035     } catch (...) {
40036       {
40037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40038       };
40039     }
40040   }
40041
40042 }
40043
40044
40045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40046   void * jresult ;
40047   Dali::PanGestureDetector *arg1 = 0 ;
40048   Dali::PanGestureDetector *result = 0 ;
40049
40050   arg1 = (Dali::PanGestureDetector *)jarg1;
40051   if (!arg1) {
40052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40053     return 0;
40054   }
40055   {
40056     try {
40057       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40058     } catch (std::out_of_range& e) {
40059       {
40060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40061       };
40062     } catch (std::exception& e) {
40063       {
40064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40065       };
40066     } catch (Dali::DaliException e) {
40067       {
40068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40069       };
40070     } catch (...) {
40071       {
40072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40073       };
40074     }
40075   }
40076
40077   jresult = (void *)result;
40078   return jresult;
40079 }
40080
40081
40082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40083   void * jresult ;
40084   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40085   Dali::PanGestureDetector *arg2 = 0 ;
40086   Dali::PanGestureDetector *result = 0 ;
40087
40088   arg1 = (Dali::PanGestureDetector *)jarg1;
40089   arg2 = (Dali::PanGestureDetector *)jarg2;
40090   if (!arg2) {
40091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40092     return 0;
40093   }
40094   {
40095     try {
40096       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40097     } catch (std::out_of_range& e) {
40098       {
40099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40100       };
40101     } catch (std::exception& e) {
40102       {
40103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40104       };
40105     } catch (Dali::DaliException e) {
40106       {
40107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40108       };
40109     } catch (...) {
40110       {
40111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40112       };
40113     }
40114   }
40115
40116   jresult = (void *)result;
40117   return jresult;
40118 }
40119
40120
40121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40122   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40123   unsigned int arg2 ;
40124
40125   arg1 = (Dali::PanGestureDetector *)jarg1;
40126   arg2 = (unsigned int)jarg2;
40127   {
40128     try {
40129       (arg1)->SetMinimumTouchesRequired(arg2);
40130     } catch (std::out_of_range& e) {
40131       {
40132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40133       };
40134     } catch (std::exception& e) {
40135       {
40136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40137       };
40138     } catch (Dali::DaliException e) {
40139       {
40140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40141       };
40142     } catch (...) {
40143       {
40144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40145       };
40146     }
40147   }
40148
40149 }
40150
40151
40152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40153   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40154   unsigned int arg2 ;
40155
40156   arg1 = (Dali::PanGestureDetector *)jarg1;
40157   arg2 = (unsigned int)jarg2;
40158   {
40159     try {
40160       (arg1)->SetMaximumTouchesRequired(arg2);
40161     } catch (std::out_of_range& e) {
40162       {
40163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40164       };
40165     } catch (std::exception& e) {
40166       {
40167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40168       };
40169     } catch (Dali::DaliException e) {
40170       {
40171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40172       };
40173     } catch (...) {
40174       {
40175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40176       };
40177     }
40178   }
40179
40180 }
40181
40182
40183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40184   unsigned int jresult ;
40185   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40186   unsigned int result;
40187
40188   arg1 = (Dali::PanGestureDetector *)jarg1;
40189   {
40190     try {
40191       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40192     } catch (std::out_of_range& e) {
40193       {
40194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40195       };
40196     } catch (std::exception& e) {
40197       {
40198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40199       };
40200     } catch (Dali::DaliException e) {
40201       {
40202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40203       };
40204     } catch (...) {
40205       {
40206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40207       };
40208     }
40209   }
40210
40211   jresult = result;
40212   return jresult;
40213 }
40214
40215
40216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40217   unsigned int jresult ;
40218   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40219   unsigned int result;
40220
40221   arg1 = (Dali::PanGestureDetector *)jarg1;
40222   {
40223     try {
40224       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40225     } catch (std::out_of_range& e) {
40226       {
40227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40228       };
40229     } catch (std::exception& e) {
40230       {
40231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40232       };
40233     } catch (Dali::DaliException e) {
40234       {
40235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40236       };
40237     } catch (...) {
40238       {
40239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40240       };
40241     }
40242   }
40243
40244   jresult = result;
40245   return jresult;
40246 }
40247
40248
40249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40250   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40251   Dali::Radian arg2 ;
40252   Dali::Radian arg3 ;
40253   Dali::Radian *argp2 ;
40254   Dali::Radian *argp3 ;
40255
40256   arg1 = (Dali::PanGestureDetector *)jarg1;
40257   argp2 = (Dali::Radian *)jarg2;
40258   if (!argp2) {
40259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40260     return ;
40261   }
40262   arg2 = *argp2;
40263   argp3 = (Dali::Radian *)jarg3;
40264   if (!argp3) {
40265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40266     return ;
40267   }
40268   arg3 = *argp3;
40269   {
40270     try {
40271       (arg1)->AddAngle(arg2,arg3);
40272     } catch (std::out_of_range& e) {
40273       {
40274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40275       };
40276     } catch (std::exception& e) {
40277       {
40278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40279       };
40280     } catch (Dali::DaliException e) {
40281       {
40282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40283       };
40284     } catch (...) {
40285       {
40286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40287       };
40288     }
40289   }
40290
40291 }
40292
40293
40294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40295   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40296   Dali::Radian arg2 ;
40297   Dali::Radian *argp2 ;
40298
40299   arg1 = (Dali::PanGestureDetector *)jarg1;
40300   argp2 = (Dali::Radian *)jarg2;
40301   if (!argp2) {
40302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40303     return ;
40304   }
40305   arg2 = *argp2;
40306   {
40307     try {
40308       (arg1)->AddAngle(arg2);
40309     } catch (std::out_of_range& e) {
40310       {
40311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40312       };
40313     } catch (std::exception& e) {
40314       {
40315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40316       };
40317     } catch (Dali::DaliException e) {
40318       {
40319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40320       };
40321     } catch (...) {
40322       {
40323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40324       };
40325     }
40326   }
40327
40328 }
40329
40330
40331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40332   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40333   Dali::Radian arg2 ;
40334   Dali::Radian arg3 ;
40335   Dali::Radian *argp2 ;
40336   Dali::Radian *argp3 ;
40337
40338   arg1 = (Dali::PanGestureDetector *)jarg1;
40339   argp2 = (Dali::Radian *)jarg2;
40340   if (!argp2) {
40341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40342     return ;
40343   }
40344   arg2 = *argp2;
40345   argp3 = (Dali::Radian *)jarg3;
40346   if (!argp3) {
40347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40348     return ;
40349   }
40350   arg3 = *argp3;
40351   {
40352     try {
40353       (arg1)->AddDirection(arg2,arg3);
40354     } catch (std::out_of_range& e) {
40355       {
40356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40357       };
40358     } catch (std::exception& e) {
40359       {
40360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40361       };
40362     } catch (Dali::DaliException e) {
40363       {
40364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40365       };
40366     } catch (...) {
40367       {
40368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40369       };
40370     }
40371   }
40372
40373 }
40374
40375
40376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40377   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40378   Dali::Radian arg2 ;
40379   Dali::Radian *argp2 ;
40380
40381   arg1 = (Dali::PanGestureDetector *)jarg1;
40382   argp2 = (Dali::Radian *)jarg2;
40383   if (!argp2) {
40384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40385     return ;
40386   }
40387   arg2 = *argp2;
40388   {
40389     try {
40390       (arg1)->AddDirection(arg2);
40391     } catch (std::out_of_range& e) {
40392       {
40393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40394       };
40395     } catch (std::exception& e) {
40396       {
40397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40398       };
40399     } catch (Dali::DaliException e) {
40400       {
40401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40402       };
40403     } catch (...) {
40404       {
40405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40406       };
40407     }
40408   }
40409
40410 }
40411
40412
40413 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40414   unsigned long jresult ;
40415   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40416   size_t result;
40417
40418   arg1 = (Dali::PanGestureDetector *)jarg1;
40419   {
40420     try {
40421       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
40422     } catch (std::out_of_range& e) {
40423       {
40424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40425       };
40426     } catch (std::exception& e) {
40427       {
40428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40429       };
40430     } catch (Dali::DaliException e) {
40431       {
40432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40433       };
40434     } catch (...) {
40435       {
40436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40437       };
40438     }
40439   }
40440
40441   jresult = (unsigned long)result;
40442   return jresult;
40443 }
40444
40445
40446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
40447   void * jresult ;
40448   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40449   size_t arg2 ;
40450   Dali::PanGestureDetector::AngleThresholdPair result;
40451
40452   arg1 = (Dali::PanGestureDetector *)jarg1;
40453   arg2 = (size_t)jarg2;
40454   {
40455     try {
40456       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
40457     } catch (std::out_of_range& e) {
40458       {
40459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40460       };
40461     } catch (std::exception& e) {
40462       {
40463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40464       };
40465     } catch (Dali::DaliException e) {
40466       {
40467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40468       };
40469     } catch (...) {
40470       {
40471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40472       };
40473     }
40474   }
40475
40476   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
40477   return jresult;
40478 }
40479
40480
40481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
40482   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40483
40484   arg1 = (Dali::PanGestureDetector *)jarg1;
40485   {
40486     try {
40487       (arg1)->ClearAngles();
40488     } catch (std::out_of_range& e) {
40489       {
40490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40491       };
40492     } catch (std::exception& e) {
40493       {
40494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40495       };
40496     } catch (Dali::DaliException e) {
40497       {
40498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40499       };
40500     } catch (...) {
40501       {
40502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40503       };
40504     }
40505   }
40506
40507 }
40508
40509
40510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
40511   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40512   Dali::Radian arg2 ;
40513   Dali::Radian *argp2 ;
40514
40515   arg1 = (Dali::PanGestureDetector *)jarg1;
40516   argp2 = (Dali::Radian *)jarg2;
40517   if (!argp2) {
40518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40519     return ;
40520   }
40521   arg2 = *argp2;
40522   {
40523     try {
40524       (arg1)->RemoveAngle(arg2);
40525     } catch (std::out_of_range& e) {
40526       {
40527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40528       };
40529     } catch (std::exception& e) {
40530       {
40531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40532       };
40533     } catch (Dali::DaliException e) {
40534       {
40535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40536       };
40537     } catch (...) {
40538       {
40539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40540       };
40541     }
40542   }
40543
40544 }
40545
40546
40547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
40548   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40549   Dali::Radian arg2 ;
40550   Dali::Radian *argp2 ;
40551
40552   arg1 = (Dali::PanGestureDetector *)jarg1;
40553   argp2 = (Dali::Radian *)jarg2;
40554   if (!argp2) {
40555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40556     return ;
40557   }
40558   arg2 = *argp2;
40559   {
40560     try {
40561       (arg1)->RemoveDirection(arg2);
40562     } catch (std::out_of_range& e) {
40563       {
40564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40565       };
40566     } catch (std::exception& e) {
40567       {
40568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40569       };
40570     } catch (Dali::DaliException e) {
40571       {
40572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40573       };
40574     } catch (...) {
40575       {
40576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40577       };
40578     }
40579   }
40580
40581 }
40582
40583
40584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
40585   void * jresult ;
40586   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40587   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
40588
40589   arg1 = (Dali::PanGestureDetector *)jarg1;
40590   {
40591     try {
40592       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
40593     } catch (std::out_of_range& e) {
40594       {
40595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40596       };
40597     } catch (std::exception& e) {
40598       {
40599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40600       };
40601     } catch (Dali::DaliException e) {
40602       {
40603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40604       };
40605     } catch (...) {
40606       {
40607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40608       };
40609     }
40610   }
40611
40612   jresult = (void *)result;
40613   return jresult;
40614 }
40615
40616
40617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
40618   Dali::PanGesture *arg1 = 0 ;
40619
40620   arg1 = (Dali::PanGesture *)jarg1;
40621   if (!arg1) {
40622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40623     return ;
40624   }
40625   {
40626     try {
40627       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
40628     } catch (std::out_of_range& e) {
40629       {
40630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40631       };
40632     } catch (std::exception& e) {
40633       {
40634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40635       };
40636     } catch (Dali::DaliException e) {
40637       {
40638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40639       };
40640     } catch (...) {
40641       {
40642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40643       };
40644     }
40645   }
40646
40647 }
40648
40649
40650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
40651   void * jresult ;
40652   Dali::PanGesture *result = 0 ;
40653
40654   {
40655     try {
40656       result = (Dali::PanGesture *)new Dali::PanGesture();
40657     } catch (std::out_of_range& e) {
40658       {
40659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40660       };
40661     } catch (std::exception& e) {
40662       {
40663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40664       };
40665     } catch (Dali::DaliException e) {
40666       {
40667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40668       };
40669     } catch (...) {
40670       {
40671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40672       };
40673     }
40674   }
40675
40676   jresult = (void *)result;
40677   return jresult;
40678 }
40679
40680
40681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
40682   void * jresult ;
40683   Dali::Gesture::State arg1 ;
40684   Dali::PanGesture *result = 0 ;
40685
40686   arg1 = (Dali::Gesture::State)jarg1;
40687   {
40688     try {
40689       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
40690     } catch (std::out_of_range& e) {
40691       {
40692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40693       };
40694     } catch (std::exception& e) {
40695       {
40696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40697       };
40698     } catch (Dali::DaliException e) {
40699       {
40700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40701       };
40702     } catch (...) {
40703       {
40704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40705       };
40706     }
40707   }
40708
40709   jresult = (void *)result;
40710   return jresult;
40711 }
40712
40713
40714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
40715   void * jresult ;
40716   Dali::PanGesture *arg1 = 0 ;
40717   Dali::PanGesture *result = 0 ;
40718
40719   arg1 = (Dali::PanGesture *)jarg1;
40720   if (!arg1) {
40721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40722     return 0;
40723   }
40724   {
40725     try {
40726       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
40727     } catch (std::out_of_range& e) {
40728       {
40729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40730       };
40731     } catch (std::exception& e) {
40732       {
40733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40734       };
40735     } catch (Dali::DaliException e) {
40736       {
40737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40738       };
40739     } catch (...) {
40740       {
40741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40742       };
40743     }
40744   }
40745
40746   jresult = (void *)result;
40747   return jresult;
40748 }
40749
40750
40751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
40752   void * jresult ;
40753   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40754   Dali::PanGesture *arg2 = 0 ;
40755   Dali::PanGesture *result = 0 ;
40756
40757   arg1 = (Dali::PanGesture *)jarg1;
40758   arg2 = (Dali::PanGesture *)jarg2;
40759   if (!arg2) {
40760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40761     return 0;
40762   }
40763   {
40764     try {
40765       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
40766     } catch (std::out_of_range& e) {
40767       {
40768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40769       };
40770     } catch (std::exception& e) {
40771       {
40772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40773       };
40774     } catch (Dali::DaliException e) {
40775       {
40776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40777       };
40778     } catch (...) {
40779       {
40780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40781       };
40782     }
40783   }
40784
40785   jresult = (void *)result;
40786   return jresult;
40787 }
40788
40789
40790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
40791   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40792
40793   arg1 = (Dali::PanGesture *)jarg1;
40794   {
40795     try {
40796       delete arg1;
40797     } catch (std::out_of_range& e) {
40798       {
40799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40800       };
40801     } catch (std::exception& e) {
40802       {
40803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40804       };
40805     } catch (Dali::DaliException e) {
40806       {
40807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40808       };
40809     } catch (...) {
40810       {
40811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40812       };
40813     }
40814   }
40815
40816 }
40817
40818
40819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
40820   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40821   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40822
40823   arg1 = (Dali::PanGesture *)jarg1;
40824   arg2 = (Dali::Vector2 *)jarg2;
40825   if (arg1) (arg1)->velocity = *arg2;
40826 }
40827
40828
40829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
40830   void * jresult ;
40831   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40832   Dali::Vector2 *result = 0 ;
40833
40834   arg1 = (Dali::PanGesture *)jarg1;
40835   result = (Dali::Vector2 *)& ((arg1)->velocity);
40836   jresult = (void *)result;
40837   return jresult;
40838 }
40839
40840
40841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
40842   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40843   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40844
40845   arg1 = (Dali::PanGesture *)jarg1;
40846   arg2 = (Dali::Vector2 *)jarg2;
40847   if (arg1) (arg1)->displacement = *arg2;
40848 }
40849
40850
40851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
40852   void * jresult ;
40853   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40854   Dali::Vector2 *result = 0 ;
40855
40856   arg1 = (Dali::PanGesture *)jarg1;
40857   result = (Dali::Vector2 *)& ((arg1)->displacement);
40858   jresult = (void *)result;
40859   return jresult;
40860 }
40861
40862
40863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
40864   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40865   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40866
40867   arg1 = (Dali::PanGesture *)jarg1;
40868   arg2 = (Dali::Vector2 *)jarg2;
40869   if (arg1) (arg1)->position = *arg2;
40870 }
40871
40872
40873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
40874   void * jresult ;
40875   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40876   Dali::Vector2 *result = 0 ;
40877
40878   arg1 = (Dali::PanGesture *)jarg1;
40879   result = (Dali::Vector2 *)& ((arg1)->position);
40880   jresult = (void *)result;
40881   return jresult;
40882 }
40883
40884
40885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
40886   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40887   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40888
40889   arg1 = (Dali::PanGesture *)jarg1;
40890   arg2 = (Dali::Vector2 *)jarg2;
40891   if (arg1) (arg1)->screenVelocity = *arg2;
40892 }
40893
40894
40895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
40896   void * jresult ;
40897   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40898   Dali::Vector2 *result = 0 ;
40899
40900   arg1 = (Dali::PanGesture *)jarg1;
40901   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
40902   jresult = (void *)result;
40903   return jresult;
40904 }
40905
40906
40907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
40908   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40909   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40910
40911   arg1 = (Dali::PanGesture *)jarg1;
40912   arg2 = (Dali::Vector2 *)jarg2;
40913   if (arg1) (arg1)->screenDisplacement = *arg2;
40914 }
40915
40916
40917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
40918   void * jresult ;
40919   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40920   Dali::Vector2 *result = 0 ;
40921
40922   arg1 = (Dali::PanGesture *)jarg1;
40923   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
40924   jresult = (void *)result;
40925   return jresult;
40926 }
40927
40928
40929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
40930   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40931   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40932
40933   arg1 = (Dali::PanGesture *)jarg1;
40934   arg2 = (Dali::Vector2 *)jarg2;
40935   if (arg1) (arg1)->screenPosition = *arg2;
40936 }
40937
40938
40939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
40940   void * jresult ;
40941   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40942   Dali::Vector2 *result = 0 ;
40943
40944   arg1 = (Dali::PanGesture *)jarg1;
40945   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
40946   jresult = (void *)result;
40947   return jresult;
40948 }
40949
40950
40951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
40952   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40953   unsigned int arg2 ;
40954
40955   arg1 = (Dali::PanGesture *)jarg1;
40956   arg2 = (unsigned int)jarg2;
40957   if (arg1) (arg1)->numberOfTouches = arg2;
40958 }
40959
40960
40961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
40962   unsigned int jresult ;
40963   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40964   unsigned int result;
40965
40966   arg1 = (Dali::PanGesture *)jarg1;
40967   result = (unsigned int) ((arg1)->numberOfTouches);
40968   jresult = result;
40969   return jresult;
40970 }
40971
40972
40973 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
40974   float jresult ;
40975   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40976   float result;
40977
40978   arg1 = (Dali::PanGesture *)jarg1;
40979   {
40980     try {
40981       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
40982     } catch (std::out_of_range& e) {
40983       {
40984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40985       };
40986     } catch (std::exception& e) {
40987       {
40988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40989       };
40990     } catch (Dali::DaliException e) {
40991       {
40992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40993       };
40994     } catch (...) {
40995       {
40996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40997       };
40998     }
40999   }
41000
41001   jresult = result;
41002   return jresult;
41003 }
41004
41005
41006 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41007   float jresult ;
41008   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41009   float result;
41010
41011   arg1 = (Dali::PanGesture *)jarg1;
41012   {
41013     try {
41014       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41015     } catch (std::out_of_range& e) {
41016       {
41017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41018       };
41019     } catch (std::exception& e) {
41020       {
41021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41022       };
41023     } catch (Dali::DaliException e) {
41024       {
41025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41026       };
41027     } catch (...) {
41028       {
41029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41030       };
41031     }
41032   }
41033
41034   jresult = result;
41035   return jresult;
41036 }
41037
41038
41039 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41040   float jresult ;
41041   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41042   float result;
41043
41044   arg1 = (Dali::PanGesture *)jarg1;
41045   {
41046     try {
41047       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41048     } catch (std::out_of_range& e) {
41049       {
41050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41051       };
41052     } catch (std::exception& e) {
41053       {
41054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41055       };
41056     } catch (Dali::DaliException e) {
41057       {
41058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41059       };
41060     } catch (...) {
41061       {
41062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41063       };
41064     }
41065   }
41066
41067   jresult = result;
41068   return jresult;
41069 }
41070
41071
41072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41073   float jresult ;
41074   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41075   float result;
41076
41077   arg1 = (Dali::PanGesture *)jarg1;
41078   {
41079     try {
41080       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41081     } catch (std::out_of_range& e) {
41082       {
41083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41084       };
41085     } catch (std::exception& e) {
41086       {
41087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41088       };
41089     } catch (Dali::DaliException e) {
41090       {
41091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41092       };
41093     } catch (...) {
41094       {
41095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41096       };
41097     }
41098   }
41099
41100   jresult = result;
41101   return jresult;
41102 }
41103
41104
41105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41106   void * jresult ;
41107   Dali::PinchGestureDetector *result = 0 ;
41108
41109   {
41110     try {
41111       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41112     } catch (std::out_of_range& e) {
41113       {
41114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41115       };
41116     } catch (std::exception& e) {
41117       {
41118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41119       };
41120     } catch (Dali::DaliException e) {
41121       {
41122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41123       };
41124     } catch (...) {
41125       {
41126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41127       };
41128     }
41129   }
41130
41131   jresult = (void *)result;
41132   return jresult;
41133 }
41134
41135
41136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41137   void * jresult ;
41138   Dali::PinchGestureDetector result;
41139
41140   {
41141     try {
41142       result = Dali::PinchGestureDetector::New();
41143     } catch (std::out_of_range& e) {
41144       {
41145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41146       };
41147     } catch (std::exception& e) {
41148       {
41149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41150       };
41151     } catch (Dali::DaliException e) {
41152       {
41153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41154       };
41155     } catch (...) {
41156       {
41157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41158       };
41159     }
41160   }
41161
41162   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41163   return jresult;
41164 }
41165
41166
41167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41168   void * jresult ;
41169   Dali::BaseHandle arg1 ;
41170   Dali::BaseHandle *argp1 ;
41171   Dali::PinchGestureDetector result;
41172
41173   argp1 = (Dali::BaseHandle *)jarg1;
41174   if (!argp1) {
41175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41176     return 0;
41177   }
41178   arg1 = *argp1;
41179   {
41180     try {
41181       result = Dali::PinchGestureDetector::DownCast(arg1);
41182     } catch (std::out_of_range& e) {
41183       {
41184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41185       };
41186     } catch (std::exception& e) {
41187       {
41188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41189       };
41190     } catch (Dali::DaliException e) {
41191       {
41192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41193       };
41194     } catch (...) {
41195       {
41196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41197       };
41198     }
41199   }
41200
41201   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41202   return jresult;
41203 }
41204
41205
41206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41207   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41208
41209   arg1 = (Dali::PinchGestureDetector *)jarg1;
41210   {
41211     try {
41212       delete arg1;
41213     } catch (std::out_of_range& e) {
41214       {
41215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41216       };
41217     } catch (std::exception& e) {
41218       {
41219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41220       };
41221     } catch (Dali::DaliException e) {
41222       {
41223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41224       };
41225     } catch (...) {
41226       {
41227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41228       };
41229     }
41230   }
41231
41232 }
41233
41234
41235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41236   void * jresult ;
41237   Dali::PinchGestureDetector *arg1 = 0 ;
41238   Dali::PinchGestureDetector *result = 0 ;
41239
41240   arg1 = (Dali::PinchGestureDetector *)jarg1;
41241   if (!arg1) {
41242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41243     return 0;
41244   }
41245   {
41246     try {
41247       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41248     } catch (std::out_of_range& e) {
41249       {
41250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41251       };
41252     } catch (std::exception& e) {
41253       {
41254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41255       };
41256     } catch (Dali::DaliException e) {
41257       {
41258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41259       };
41260     } catch (...) {
41261       {
41262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41263       };
41264     }
41265   }
41266
41267   jresult = (void *)result;
41268   return jresult;
41269 }
41270
41271
41272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41273   void * jresult ;
41274   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41275   Dali::PinchGestureDetector *arg2 = 0 ;
41276   Dali::PinchGestureDetector *result = 0 ;
41277
41278   arg1 = (Dali::PinchGestureDetector *)jarg1;
41279   arg2 = (Dali::PinchGestureDetector *)jarg2;
41280   if (!arg2) {
41281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41282     return 0;
41283   }
41284   {
41285     try {
41286       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41287     } catch (std::out_of_range& e) {
41288       {
41289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41290       };
41291     } catch (std::exception& e) {
41292       {
41293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41294       };
41295     } catch (Dali::DaliException e) {
41296       {
41297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41298       };
41299     } catch (...) {
41300       {
41301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41302       };
41303     }
41304   }
41305
41306   jresult = (void *)result;
41307   return jresult;
41308 }
41309
41310
41311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41312   void * jresult ;
41313   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41314   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41315
41316   arg1 = (Dali::PinchGestureDetector *)jarg1;
41317   {
41318     try {
41319       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41320     } catch (std::out_of_range& e) {
41321       {
41322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41323       };
41324     } catch (std::exception& e) {
41325       {
41326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41327       };
41328     } catch (Dali::DaliException e) {
41329       {
41330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41331       };
41332     } catch (...) {
41333       {
41334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41335       };
41336     }
41337   }
41338
41339   jresult = (void *)result;
41340   return jresult;
41341 }
41342
41343
41344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41345   void * jresult ;
41346   Dali::Gesture::State arg1 ;
41347   Dali::PinchGesture *result = 0 ;
41348
41349   arg1 = (Dali::Gesture::State)jarg1;
41350   {
41351     try {
41352       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41353     } catch (std::out_of_range& e) {
41354       {
41355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41356       };
41357     } catch (std::exception& e) {
41358       {
41359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41360       };
41361     } catch (Dali::DaliException e) {
41362       {
41363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41364       };
41365     } catch (...) {
41366       {
41367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41368       };
41369     }
41370   }
41371
41372   jresult = (void *)result;
41373   return jresult;
41374 }
41375
41376
41377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41378   void * jresult ;
41379   Dali::PinchGesture *arg1 = 0 ;
41380   Dali::PinchGesture *result = 0 ;
41381
41382   arg1 = (Dali::PinchGesture *)jarg1;
41383   if (!arg1) {
41384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41385     return 0;
41386   }
41387   {
41388     try {
41389       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41390     } catch (std::out_of_range& e) {
41391       {
41392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41393       };
41394     } catch (std::exception& e) {
41395       {
41396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41397       };
41398     } catch (Dali::DaliException e) {
41399       {
41400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41401       };
41402     } catch (...) {
41403       {
41404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41405       };
41406     }
41407   }
41408
41409   jresult = (void *)result;
41410   return jresult;
41411 }
41412
41413
41414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
41415   void * jresult ;
41416   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41417   Dali::PinchGesture *arg2 = 0 ;
41418   Dali::PinchGesture *result = 0 ;
41419
41420   arg1 = (Dali::PinchGesture *)jarg1;
41421   arg2 = (Dali::PinchGesture *)jarg2;
41422   if (!arg2) {
41423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41424     return 0;
41425   }
41426   {
41427     try {
41428       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
41429     } catch (std::out_of_range& e) {
41430       {
41431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41432       };
41433     } catch (std::exception& e) {
41434       {
41435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41436       };
41437     } catch (Dali::DaliException e) {
41438       {
41439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41440       };
41441     } catch (...) {
41442       {
41443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41444       };
41445     }
41446   }
41447
41448   jresult = (void *)result;
41449   return jresult;
41450 }
41451
41452
41453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
41454   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41455
41456   arg1 = (Dali::PinchGesture *)jarg1;
41457   {
41458     try {
41459       delete arg1;
41460     } catch (std::out_of_range& e) {
41461       {
41462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41463       };
41464     } catch (std::exception& e) {
41465       {
41466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41467       };
41468     } catch (Dali::DaliException e) {
41469       {
41470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41471       };
41472     } catch (...) {
41473       {
41474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41475       };
41476     }
41477   }
41478
41479 }
41480
41481
41482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
41483   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41484   float arg2 ;
41485
41486   arg1 = (Dali::PinchGesture *)jarg1;
41487   arg2 = (float)jarg2;
41488   if (arg1) (arg1)->scale = arg2;
41489 }
41490
41491
41492 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
41493   float jresult ;
41494   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41495   float result;
41496
41497   arg1 = (Dali::PinchGesture *)jarg1;
41498   result = (float) ((arg1)->scale);
41499   jresult = result;
41500   return jresult;
41501 }
41502
41503
41504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
41505   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41506   float arg2 ;
41507
41508   arg1 = (Dali::PinchGesture *)jarg1;
41509   arg2 = (float)jarg2;
41510   if (arg1) (arg1)->speed = arg2;
41511 }
41512
41513
41514 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
41515   float jresult ;
41516   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41517   float result;
41518
41519   arg1 = (Dali::PinchGesture *)jarg1;
41520   result = (float) ((arg1)->speed);
41521   jresult = result;
41522   return jresult;
41523 }
41524
41525
41526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
41527   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41528   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41529
41530   arg1 = (Dali::PinchGesture *)jarg1;
41531   arg2 = (Dali::Vector2 *)jarg2;
41532   if (arg1) (arg1)->screenCenterPoint = *arg2;
41533 }
41534
41535
41536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
41537   void * jresult ;
41538   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41539   Dali::Vector2 *result = 0 ;
41540
41541   arg1 = (Dali::PinchGesture *)jarg1;
41542   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
41543   jresult = (void *)result;
41544   return jresult;
41545 }
41546
41547
41548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
41549   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41550   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41551
41552   arg1 = (Dali::PinchGesture *)jarg1;
41553   arg2 = (Dali::Vector2 *)jarg2;
41554   if (arg1) (arg1)->localCenterPoint = *arg2;
41555 }
41556
41557
41558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
41559   void * jresult ;
41560   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41561   Dali::Vector2 *result = 0 ;
41562
41563   arg1 = (Dali::PinchGesture *)jarg1;
41564   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
41565   jresult = (void *)result;
41566   return jresult;
41567 }
41568
41569
41570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
41571   void * jresult ;
41572   Dali::TapGestureDetector *result = 0 ;
41573
41574   {
41575     try {
41576       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
41577     } catch (std::out_of_range& e) {
41578       {
41579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41580       };
41581     } catch (std::exception& e) {
41582       {
41583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41584       };
41585     } catch (Dali::DaliException e) {
41586       {
41587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41588       };
41589     } catch (...) {
41590       {
41591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41592       };
41593     }
41594   }
41595
41596   jresult = (void *)result;
41597   return jresult;
41598 }
41599
41600
41601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
41602   void * jresult ;
41603   Dali::TapGestureDetector result;
41604
41605   {
41606     try {
41607       result = Dali::TapGestureDetector::New();
41608     } catch (std::out_of_range& e) {
41609       {
41610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41611       };
41612     } catch (std::exception& e) {
41613       {
41614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41615       };
41616     } catch (Dali::DaliException e) {
41617       {
41618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41619       };
41620     } catch (...) {
41621       {
41622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41623       };
41624     }
41625   }
41626
41627   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41628   return jresult;
41629 }
41630
41631
41632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
41633   void * jresult ;
41634   unsigned int arg1 ;
41635   Dali::TapGestureDetector result;
41636
41637   arg1 = (unsigned int)jarg1;
41638   {
41639     try {
41640       result = Dali::TapGestureDetector::New(arg1);
41641     } catch (std::out_of_range& e) {
41642       {
41643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41644       };
41645     } catch (std::exception& e) {
41646       {
41647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41648       };
41649     } catch (Dali::DaliException e) {
41650       {
41651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41652       };
41653     } catch (...) {
41654       {
41655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41656       };
41657     }
41658   }
41659
41660   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41661   return jresult;
41662 }
41663
41664
41665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
41666   void * jresult ;
41667   Dali::BaseHandle arg1 ;
41668   Dali::BaseHandle *argp1 ;
41669   Dali::TapGestureDetector result;
41670
41671   argp1 = (Dali::BaseHandle *)jarg1;
41672   if (!argp1) {
41673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41674     return 0;
41675   }
41676   arg1 = *argp1;
41677   {
41678     try {
41679       result = Dali::TapGestureDetector::DownCast(arg1);
41680     } catch (std::out_of_range& e) {
41681       {
41682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41683       };
41684     } catch (std::exception& e) {
41685       {
41686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41687       };
41688     } catch (Dali::DaliException e) {
41689       {
41690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41691       };
41692     } catch (...) {
41693       {
41694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41695       };
41696     }
41697   }
41698
41699   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41700   return jresult;
41701 }
41702
41703
41704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
41705   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41706
41707   arg1 = (Dali::TapGestureDetector *)jarg1;
41708   {
41709     try {
41710       delete arg1;
41711     } catch (std::out_of_range& e) {
41712       {
41713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41714       };
41715     } catch (std::exception& e) {
41716       {
41717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41718       };
41719     } catch (Dali::DaliException e) {
41720       {
41721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41722       };
41723     } catch (...) {
41724       {
41725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41726       };
41727     }
41728   }
41729
41730 }
41731
41732
41733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
41734   void * jresult ;
41735   Dali::TapGestureDetector *arg1 = 0 ;
41736   Dali::TapGestureDetector *result = 0 ;
41737
41738   arg1 = (Dali::TapGestureDetector *)jarg1;
41739   if (!arg1) {
41740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41741     return 0;
41742   }
41743   {
41744     try {
41745       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
41746     } catch (std::out_of_range& e) {
41747       {
41748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41749       };
41750     } catch (std::exception& e) {
41751       {
41752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41753       };
41754     } catch (Dali::DaliException e) {
41755       {
41756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41757       };
41758     } catch (...) {
41759       {
41760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41761       };
41762     }
41763   }
41764
41765   jresult = (void *)result;
41766   return jresult;
41767 }
41768
41769
41770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
41771   void * jresult ;
41772   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41773   Dali::TapGestureDetector *arg2 = 0 ;
41774   Dali::TapGestureDetector *result = 0 ;
41775
41776   arg1 = (Dali::TapGestureDetector *)jarg1;
41777   arg2 = (Dali::TapGestureDetector *)jarg2;
41778   if (!arg2) {
41779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41780     return 0;
41781   }
41782   {
41783     try {
41784       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
41785     } catch (std::out_of_range& e) {
41786       {
41787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41788       };
41789     } catch (std::exception& e) {
41790       {
41791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41792       };
41793     } catch (Dali::DaliException e) {
41794       {
41795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41796       };
41797     } catch (...) {
41798       {
41799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41800       };
41801     }
41802   }
41803
41804   jresult = (void *)result;
41805   return jresult;
41806 }
41807
41808
41809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
41810   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41811   unsigned int arg2 ;
41812
41813   arg1 = (Dali::TapGestureDetector *)jarg1;
41814   arg2 = (unsigned int)jarg2;
41815   {
41816     try {
41817       (arg1)->SetMinimumTapsRequired(arg2);
41818     } catch (std::out_of_range& e) {
41819       {
41820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41821       };
41822     } catch (std::exception& e) {
41823       {
41824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41825       };
41826     } catch (Dali::DaliException e) {
41827       {
41828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41829       };
41830     } catch (...) {
41831       {
41832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41833       };
41834     }
41835   }
41836
41837 }
41838
41839
41840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
41841   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41842   unsigned int arg2 ;
41843
41844   arg1 = (Dali::TapGestureDetector *)jarg1;
41845   arg2 = (unsigned int)jarg2;
41846   {
41847     try {
41848       (arg1)->SetMaximumTapsRequired(arg2);
41849     } catch (std::out_of_range& e) {
41850       {
41851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41852       };
41853     } catch (std::exception& e) {
41854       {
41855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41856       };
41857     } catch (Dali::DaliException e) {
41858       {
41859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41860       };
41861     } catch (...) {
41862       {
41863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41864       };
41865     }
41866   }
41867
41868 }
41869
41870
41871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
41872   unsigned int jresult ;
41873   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41874   unsigned int result;
41875
41876   arg1 = (Dali::TapGestureDetector *)jarg1;
41877   {
41878     try {
41879       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
41880     } catch (std::out_of_range& e) {
41881       {
41882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41883       };
41884     } catch (std::exception& e) {
41885       {
41886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41887       };
41888     } catch (Dali::DaliException e) {
41889       {
41890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41891       };
41892     } catch (...) {
41893       {
41894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41895       };
41896     }
41897   }
41898
41899   jresult = result;
41900   return jresult;
41901 }
41902
41903
41904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
41905   unsigned int jresult ;
41906   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41907   unsigned int result;
41908
41909   arg1 = (Dali::TapGestureDetector *)jarg1;
41910   {
41911     try {
41912       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
41913     } catch (std::out_of_range& e) {
41914       {
41915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41916       };
41917     } catch (std::exception& e) {
41918       {
41919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41920       };
41921     } catch (Dali::DaliException e) {
41922       {
41923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41924       };
41925     } catch (...) {
41926       {
41927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41928       };
41929     }
41930   }
41931
41932   jresult = result;
41933   return jresult;
41934 }
41935
41936
41937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
41938   void * jresult ;
41939   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41940   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
41941
41942   arg1 = (Dali::TapGestureDetector *)jarg1;
41943   {
41944     try {
41945       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41946     } catch (std::out_of_range& e) {
41947       {
41948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41949       };
41950     } catch (std::exception& e) {
41951       {
41952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41953       };
41954     } catch (Dali::DaliException e) {
41955       {
41956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41957       };
41958     } catch (...) {
41959       {
41960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41961       };
41962     }
41963   }
41964
41965   jresult = (void *)result;
41966   return jresult;
41967 }
41968
41969
41970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
41971   void * jresult ;
41972   Dali::TapGesture *result = 0 ;
41973
41974   {
41975     try {
41976       result = (Dali::TapGesture *)new Dali::TapGesture();
41977     } catch (std::out_of_range& e) {
41978       {
41979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41980       };
41981     } catch (std::exception& e) {
41982       {
41983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41984       };
41985     } catch (Dali::DaliException e) {
41986       {
41987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41988       };
41989     } catch (...) {
41990       {
41991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41992       };
41993     }
41994   }
41995
41996   jresult = (void *)result;
41997   return jresult;
41998 }
41999
42000
42001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42002   void * jresult ;
42003   Dali::TapGesture *arg1 = 0 ;
42004   Dali::TapGesture *result = 0 ;
42005
42006   arg1 = (Dali::TapGesture *)jarg1;
42007   if (!arg1) {
42008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42009     return 0;
42010   }
42011   {
42012     try {
42013       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42014     } catch (std::out_of_range& e) {
42015       {
42016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42017       };
42018     } catch (std::exception& e) {
42019       {
42020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42021       };
42022     } catch (Dali::DaliException e) {
42023       {
42024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42025       };
42026     } catch (...) {
42027       {
42028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42029       };
42030     }
42031   }
42032
42033   jresult = (void *)result;
42034   return jresult;
42035 }
42036
42037
42038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42039   void * jresult ;
42040   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42041   Dali::TapGesture *arg2 = 0 ;
42042   Dali::TapGesture *result = 0 ;
42043
42044   arg1 = (Dali::TapGesture *)jarg1;
42045   arg2 = (Dali::TapGesture *)jarg2;
42046   if (!arg2) {
42047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42048     return 0;
42049   }
42050   {
42051     try {
42052       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42053     } catch (std::out_of_range& e) {
42054       {
42055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42056       };
42057     } catch (std::exception& e) {
42058       {
42059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42060       };
42061     } catch (Dali::DaliException e) {
42062       {
42063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42064       };
42065     } catch (...) {
42066       {
42067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42068       };
42069     }
42070   }
42071
42072   jresult = (void *)result;
42073   return jresult;
42074 }
42075
42076
42077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42078   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42079
42080   arg1 = (Dali::TapGesture *)jarg1;
42081   {
42082     try {
42083       delete arg1;
42084     } catch (std::out_of_range& e) {
42085       {
42086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42087       };
42088     } catch (std::exception& e) {
42089       {
42090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42091       };
42092     } catch (Dali::DaliException e) {
42093       {
42094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42095       };
42096     } catch (...) {
42097       {
42098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42099       };
42100     }
42101   }
42102
42103 }
42104
42105
42106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42107   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42108   unsigned int arg2 ;
42109
42110   arg1 = (Dali::TapGesture *)jarg1;
42111   arg2 = (unsigned int)jarg2;
42112   if (arg1) (arg1)->numberOfTaps = arg2;
42113 }
42114
42115
42116 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42117   unsigned int jresult ;
42118   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42119   unsigned int result;
42120
42121   arg1 = (Dali::TapGesture *)jarg1;
42122   result = (unsigned int) ((arg1)->numberOfTaps);
42123   jresult = result;
42124   return jresult;
42125 }
42126
42127
42128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42129   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42130   unsigned int arg2 ;
42131
42132   arg1 = (Dali::TapGesture *)jarg1;
42133   arg2 = (unsigned int)jarg2;
42134   if (arg1) (arg1)->numberOfTouches = arg2;
42135 }
42136
42137
42138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42139   unsigned int jresult ;
42140   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42141   unsigned int result;
42142
42143   arg1 = (Dali::TapGesture *)jarg1;
42144   result = (unsigned int) ((arg1)->numberOfTouches);
42145   jresult = result;
42146   return jresult;
42147 }
42148
42149
42150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42151   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42152   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42153
42154   arg1 = (Dali::TapGesture *)jarg1;
42155   arg2 = (Dali::Vector2 *)jarg2;
42156   if (arg1) (arg1)->screenPoint = *arg2;
42157 }
42158
42159
42160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42161   void * jresult ;
42162   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42163   Dali::Vector2 *result = 0 ;
42164
42165   arg1 = (Dali::TapGesture *)jarg1;
42166   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42167   jresult = (void *)result;
42168   return jresult;
42169 }
42170
42171
42172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42173   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42174   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42175
42176   arg1 = (Dali::TapGesture *)jarg1;
42177   arg2 = (Dali::Vector2 *)jarg2;
42178   if (arg1) (arg1)->localPoint = *arg2;
42179 }
42180
42181
42182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42183   void * jresult ;
42184   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42185   Dali::Vector2 *result = 0 ;
42186
42187   arg1 = (Dali::TapGesture *)jarg1;
42188   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42189   jresult = (void *)result;
42190   return jresult;
42191 }
42192
42193
42194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42195   void * jresult ;
42196   Dali::AlphaFunction *result = 0 ;
42197
42198   {
42199     try {
42200       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42201     } catch (std::out_of_range& e) {
42202       {
42203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42204       };
42205     } catch (std::exception& e) {
42206       {
42207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42208       };
42209     } catch (Dali::DaliException e) {
42210       {
42211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42212       };
42213     } catch (...) {
42214       {
42215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42216       };
42217     }
42218   }
42219
42220   jresult = (void *)result;
42221   return jresult;
42222 }
42223
42224
42225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42226   void * jresult ;
42227   Dali::AlphaFunction::BuiltinFunction arg1 ;
42228   Dali::AlphaFunction *result = 0 ;
42229
42230   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42231   {
42232     try {
42233       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42234     } catch (std::out_of_range& e) {
42235       {
42236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42237       };
42238     } catch (std::exception& e) {
42239       {
42240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42241       };
42242     } catch (Dali::DaliException e) {
42243       {
42244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42245       };
42246     } catch (...) {
42247       {
42248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42249       };
42250     }
42251   }
42252
42253   jresult = (void *)result;
42254   return jresult;
42255 }
42256
42257
42258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42259   void * jresult ;
42260   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42261   Dali::AlphaFunction *result = 0 ;
42262
42263   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42264   {
42265     try {
42266       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42267     } catch (std::out_of_range& e) {
42268       {
42269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42270       };
42271     } catch (std::exception& e) {
42272       {
42273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42274       };
42275     } catch (Dali::DaliException e) {
42276       {
42277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42278       };
42279     } catch (...) {
42280       {
42281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42282       };
42283     }
42284   }
42285
42286   jresult = (void *)result;
42287   return jresult;
42288 }
42289
42290
42291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42292   void * jresult ;
42293   Dali::Vector2 *arg1 = 0 ;
42294   Dali::Vector2 *arg2 = 0 ;
42295   Dali::AlphaFunction *result = 0 ;
42296
42297   arg1 = (Dali::Vector2 *)jarg1;
42298   if (!arg1) {
42299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42300     return 0;
42301   }
42302   arg2 = (Dali::Vector2 *)jarg2;
42303   if (!arg2) {
42304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42305     return 0;
42306   }
42307   {
42308     try {
42309       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42310     } catch (std::out_of_range& e) {
42311       {
42312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42313       };
42314     } catch (std::exception& e) {
42315       {
42316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42317       };
42318     } catch (Dali::DaliException e) {
42319       {
42320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42321       };
42322     } catch (...) {
42323       {
42324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42325       };
42326     }
42327   }
42328
42329   jresult = (void *)result;
42330   return jresult;
42331 }
42332
42333
42334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42335   void * jresult ;
42336   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42337   Dali::Vector4 result;
42338
42339   arg1 = (Dali::AlphaFunction *)jarg1;
42340   {
42341     try {
42342       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42343     } catch (std::out_of_range& e) {
42344       {
42345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42346       };
42347     } catch (std::exception& e) {
42348       {
42349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42350       };
42351     } catch (Dali::DaliException e) {
42352       {
42353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42354       };
42355     } catch (...) {
42356       {
42357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42358       };
42359     }
42360   }
42361
42362   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42363   return jresult;
42364 }
42365
42366
42367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42368   void * jresult ;
42369   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42370   Dali::AlphaFunctionPrototype result;
42371
42372   arg1 = (Dali::AlphaFunction *)jarg1;
42373   {
42374     try {
42375       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42376     } catch (std::out_of_range& e) {
42377       {
42378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42379       };
42380     } catch (std::exception& e) {
42381       {
42382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42383       };
42384     } catch (Dali::DaliException e) {
42385       {
42386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42387       };
42388     } catch (...) {
42389       {
42390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42391       };
42392     }
42393   }
42394
42395   jresult = (void *)result;
42396   return jresult;
42397 }
42398
42399
42400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42401   int jresult ;
42402   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42403   Dali::AlphaFunction::BuiltinFunction result;
42404
42405   arg1 = (Dali::AlphaFunction *)jarg1;
42406   {
42407     try {
42408       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
42409     } catch (std::out_of_range& e) {
42410       {
42411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42412       };
42413     } catch (std::exception& e) {
42414       {
42415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42416       };
42417     } catch (Dali::DaliException e) {
42418       {
42419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42420       };
42421     } catch (...) {
42422       {
42423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42424       };
42425     }
42426   }
42427
42428   jresult = (int)result;
42429   return jresult;
42430 }
42431
42432
42433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
42434   int jresult ;
42435   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42436   Dali::AlphaFunction::Mode result;
42437
42438   arg1 = (Dali::AlphaFunction *)jarg1;
42439   {
42440     try {
42441       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
42442     } catch (std::out_of_range& e) {
42443       {
42444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42445       };
42446     } catch (std::exception& e) {
42447       {
42448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42449       };
42450     } catch (Dali::DaliException e) {
42451       {
42452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42453       };
42454     } catch (...) {
42455       {
42456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42457       };
42458     }
42459   }
42460
42461   jresult = (int)result;
42462   return jresult;
42463 }
42464
42465
42466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
42467   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42468
42469   arg1 = (Dali::AlphaFunction *)jarg1;
42470   {
42471     try {
42472       delete arg1;
42473     } catch (std::out_of_range& e) {
42474       {
42475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42476       };
42477     } catch (std::exception& e) {
42478       {
42479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42480       };
42481     } catch (Dali::DaliException e) {
42482       {
42483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42484       };
42485     } catch (...) {
42486       {
42487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42488       };
42489     }
42490   }
42491
42492 }
42493
42494
42495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
42496   void * jresult ;
42497   Dali::KeyFrames result;
42498
42499   {
42500     try {
42501       result = Dali::KeyFrames::New();
42502     } catch (std::out_of_range& e) {
42503       {
42504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42505       };
42506     } catch (std::exception& e) {
42507       {
42508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42509       };
42510     } catch (Dali::DaliException e) {
42511       {
42512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42513       };
42514     } catch (...) {
42515       {
42516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42517       };
42518     }
42519   }
42520
42521   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42522   return jresult;
42523 }
42524
42525
42526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
42527   void * jresult ;
42528   Dali::BaseHandle arg1 ;
42529   Dali::BaseHandle *argp1 ;
42530   Dali::KeyFrames result;
42531
42532   argp1 = (Dali::BaseHandle *)jarg1;
42533   if (!argp1) {
42534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42535     return 0;
42536   }
42537   arg1 = *argp1;
42538   {
42539     try {
42540       result = Dali::KeyFrames::DownCast(arg1);
42541     } catch (std::out_of_range& e) {
42542       {
42543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42544       };
42545     } catch (std::exception& e) {
42546       {
42547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42548       };
42549     } catch (Dali::DaliException e) {
42550       {
42551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42552       };
42553     } catch (...) {
42554       {
42555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42556       };
42557     }
42558   }
42559
42560   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42561   return jresult;
42562 }
42563
42564
42565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
42566   void * jresult ;
42567   Dali::KeyFrames *result = 0 ;
42568
42569   {
42570     try {
42571       result = (Dali::KeyFrames *)new Dali::KeyFrames();
42572     } catch (std::out_of_range& e) {
42573       {
42574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42575       };
42576     } catch (std::exception& e) {
42577       {
42578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42579       };
42580     } catch (Dali::DaliException e) {
42581       {
42582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42583       };
42584     } catch (...) {
42585       {
42586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42587       };
42588     }
42589   }
42590
42591   jresult = (void *)result;
42592   return jresult;
42593 }
42594
42595
42596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
42597   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42598
42599   arg1 = (Dali::KeyFrames *)jarg1;
42600   {
42601     try {
42602       delete arg1;
42603     } catch (std::out_of_range& e) {
42604       {
42605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42606       };
42607     } catch (std::exception& e) {
42608       {
42609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42610       };
42611     } catch (Dali::DaliException e) {
42612       {
42613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42614       };
42615     } catch (...) {
42616       {
42617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42618       };
42619     }
42620   }
42621
42622 }
42623
42624
42625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
42626   void * jresult ;
42627   Dali::KeyFrames *arg1 = 0 ;
42628   Dali::KeyFrames *result = 0 ;
42629
42630   arg1 = (Dali::KeyFrames *)jarg1;
42631   if (!arg1) {
42632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42633     return 0;
42634   }
42635   {
42636     try {
42637       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
42638     } catch (std::out_of_range& e) {
42639       {
42640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42641       };
42642     } catch (std::exception& e) {
42643       {
42644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42645       };
42646     } catch (Dali::DaliException e) {
42647       {
42648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42649       };
42650     } catch (...) {
42651       {
42652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42653       };
42654     }
42655   }
42656
42657   jresult = (void *)result;
42658   return jresult;
42659 }
42660
42661
42662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
42663   void * jresult ;
42664   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42665   Dali::KeyFrames *arg2 = 0 ;
42666   Dali::KeyFrames *result = 0 ;
42667
42668   arg1 = (Dali::KeyFrames *)jarg1;
42669   arg2 = (Dali::KeyFrames *)jarg2;
42670   if (!arg2) {
42671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42672     return 0;
42673   }
42674   {
42675     try {
42676       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
42677     } catch (std::out_of_range& e) {
42678       {
42679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42680       };
42681     } catch (std::exception& e) {
42682       {
42683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42684       };
42685     } catch (Dali::DaliException e) {
42686       {
42687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42688       };
42689     } catch (...) {
42690       {
42691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42692       };
42693     }
42694   }
42695
42696   jresult = (void *)result;
42697   return jresult;
42698 }
42699
42700
42701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
42702   int jresult ;
42703   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42704   Dali::Property::Type result;
42705
42706   arg1 = (Dali::KeyFrames *)jarg1;
42707   {
42708     try {
42709       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
42710     } catch (std::out_of_range& e) {
42711       {
42712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42713       };
42714     } catch (std::exception& e) {
42715       {
42716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42717       };
42718     } catch (Dali::DaliException e) {
42719       {
42720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42721       };
42722     } catch (...) {
42723       {
42724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42725       };
42726     }
42727   }
42728
42729   jresult = (int)result;
42730   return jresult;
42731 }
42732
42733
42734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
42735   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42736   float arg2 ;
42737   Dali::Property::Value arg3 ;
42738   Dali::Property::Value *argp3 ;
42739
42740   arg1 = (Dali::KeyFrames *)jarg1;
42741   arg2 = (float)jarg2;
42742   argp3 = (Dali::Property::Value *)jarg3;
42743   if (!argp3) {
42744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42745     return ;
42746   }
42747   arg3 = *argp3;
42748   {
42749     try {
42750       (arg1)->Add(arg2,arg3);
42751     } catch (std::out_of_range& e) {
42752       {
42753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42754       };
42755     } catch (std::exception& e) {
42756       {
42757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42758       };
42759     } catch (Dali::DaliException e) {
42760       {
42761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42762       };
42763     } catch (...) {
42764       {
42765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42766       };
42767     }
42768   }
42769
42770 }
42771
42772
42773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
42774   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42775   float arg2 ;
42776   Dali::Property::Value arg3 ;
42777   Dali::AlphaFunction arg4 ;
42778   Dali::Property::Value *argp3 ;
42779   Dali::AlphaFunction *argp4 ;
42780
42781   arg1 = (Dali::KeyFrames *)jarg1;
42782   arg2 = (float)jarg2;
42783   argp3 = (Dali::Property::Value *)jarg3;
42784   if (!argp3) {
42785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42786     return ;
42787   }
42788   arg3 = *argp3;
42789   argp4 = (Dali::AlphaFunction *)jarg4;
42790   if (!argp4) {
42791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
42792     return ;
42793   }
42794   arg4 = *argp4;
42795   {
42796     try {
42797       (arg1)->Add(arg2,arg3,arg4);
42798     } catch (std::out_of_range& e) {
42799       {
42800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42801       };
42802     } catch (std::exception& e) {
42803       {
42804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42805       };
42806     } catch (Dali::DaliException e) {
42807       {
42808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42809       };
42810     } catch (...) {
42811       {
42812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42813       };
42814     }
42815   }
42816
42817 }
42818
42819
42820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
42821   int jresult ;
42822   int result;
42823
42824   result = (int)Dali::Path::Property::POINTS;
42825   jresult = (int)result;
42826   return jresult;
42827 }
42828
42829
42830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
42831   int jresult ;
42832   int result;
42833
42834   result = (int)Dali::Path::Property::CONTROL_POINTS;
42835   jresult = (int)result;
42836   return jresult;
42837 }
42838
42839
42840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
42841   void * jresult ;
42842   Dali::Path::Property *result = 0 ;
42843
42844   {
42845     try {
42846       result = (Dali::Path::Property *)new Dali::Path::Property();
42847     } catch (std::out_of_range& e) {
42848       {
42849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42850       };
42851     } catch (std::exception& e) {
42852       {
42853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42854       };
42855     } catch (Dali::DaliException e) {
42856       {
42857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42858       };
42859     } catch (...) {
42860       {
42861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42862       };
42863     }
42864   }
42865
42866   jresult = (void *)result;
42867   return jresult;
42868 }
42869
42870
42871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
42872   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
42873
42874   arg1 = (Dali::Path::Property *)jarg1;
42875   {
42876     try {
42877       delete arg1;
42878     } catch (std::out_of_range& e) {
42879       {
42880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42881       };
42882     } catch (std::exception& e) {
42883       {
42884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42885       };
42886     } catch (Dali::DaliException e) {
42887       {
42888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42889       };
42890     } catch (...) {
42891       {
42892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42893       };
42894     }
42895   }
42896
42897 }
42898
42899
42900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
42901   void * jresult ;
42902   Dali::Path result;
42903
42904   {
42905     try {
42906       result = Dali::Path::New();
42907     } catch (std::out_of_range& e) {
42908       {
42909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42910       };
42911     } catch (std::exception& e) {
42912       {
42913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42914       };
42915     } catch (Dali::DaliException e) {
42916       {
42917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42918       };
42919     } catch (...) {
42920       {
42921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42922       };
42923     }
42924   }
42925
42926   jresult = new Dali::Path((const Dali::Path &)result);
42927   return jresult;
42928 }
42929
42930
42931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
42932   void * jresult ;
42933   Dali::BaseHandle arg1 ;
42934   Dali::BaseHandle *argp1 ;
42935   Dali::Path result;
42936
42937   argp1 = (Dali::BaseHandle *)jarg1;
42938   if (!argp1) {
42939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42940     return 0;
42941   }
42942   arg1 = *argp1;
42943   {
42944     try {
42945       result = Dali::Path::DownCast(arg1);
42946     } catch (std::out_of_range& e) {
42947       {
42948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42949       };
42950     } catch (std::exception& e) {
42951       {
42952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42953       };
42954     } catch (Dali::DaliException e) {
42955       {
42956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42957       };
42958     } catch (...) {
42959       {
42960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42961       };
42962     }
42963   }
42964
42965   jresult = new Dali::Path((const Dali::Path &)result);
42966   return jresult;
42967 }
42968
42969
42970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
42971   void * jresult ;
42972   Dali::Path *result = 0 ;
42973
42974   {
42975     try {
42976       result = (Dali::Path *)new Dali::Path();
42977     } catch (std::out_of_range& e) {
42978       {
42979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42980       };
42981     } catch (std::exception& e) {
42982       {
42983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42984       };
42985     } catch (Dali::DaliException e) {
42986       {
42987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42988       };
42989     } catch (...) {
42990       {
42991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42992       };
42993     }
42994   }
42995
42996   jresult = (void *)result;
42997   return jresult;
42998 }
42999
43000
43001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43002   Dali::Path *arg1 = (Dali::Path *) 0 ;
43003
43004   arg1 = (Dali::Path *)jarg1;
43005   {
43006     try {
43007       delete arg1;
43008     } catch (std::out_of_range& e) {
43009       {
43010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43011       };
43012     } catch (std::exception& e) {
43013       {
43014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43015       };
43016     } catch (Dali::DaliException e) {
43017       {
43018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43019       };
43020     } catch (...) {
43021       {
43022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43023       };
43024     }
43025   }
43026
43027 }
43028
43029
43030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43031   void * jresult ;
43032   Dali::Path *arg1 = 0 ;
43033   Dali::Path *result = 0 ;
43034
43035   arg1 = (Dali::Path *)jarg1;
43036   if (!arg1) {
43037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43038     return 0;
43039   }
43040   {
43041     try {
43042       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43043     } catch (std::out_of_range& e) {
43044       {
43045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43046       };
43047     } catch (std::exception& e) {
43048       {
43049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43050       };
43051     } catch (Dali::DaliException e) {
43052       {
43053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43054       };
43055     } catch (...) {
43056       {
43057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43058       };
43059     }
43060   }
43061
43062   jresult = (void *)result;
43063   return jresult;
43064 }
43065
43066
43067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43068   void * jresult ;
43069   Dali::Path *arg1 = (Dali::Path *) 0 ;
43070   Dali::Path *arg2 = 0 ;
43071   Dali::Path *result = 0 ;
43072
43073   arg1 = (Dali::Path *)jarg1;
43074   arg2 = (Dali::Path *)jarg2;
43075   if (!arg2) {
43076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43077     return 0;
43078   }
43079   {
43080     try {
43081       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43082     } catch (std::out_of_range& e) {
43083       {
43084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43085       };
43086     } catch (std::exception& e) {
43087       {
43088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43089       };
43090     } catch (Dali::DaliException e) {
43091       {
43092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43093       };
43094     } catch (...) {
43095       {
43096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43097       };
43098     }
43099   }
43100
43101   jresult = (void *)result;
43102   return jresult;
43103 }
43104
43105
43106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43107   Dali::Path *arg1 = (Dali::Path *) 0 ;
43108   Dali::Vector3 *arg2 = 0 ;
43109
43110   arg1 = (Dali::Path *)jarg1;
43111   arg2 = (Dali::Vector3 *)jarg2;
43112   if (!arg2) {
43113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43114     return ;
43115   }
43116   {
43117     try {
43118       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43119     } catch (std::out_of_range& e) {
43120       {
43121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43122       };
43123     } catch (std::exception& e) {
43124       {
43125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43126       };
43127     } catch (Dali::DaliException e) {
43128       {
43129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43130       };
43131     } catch (...) {
43132       {
43133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43134       };
43135     }
43136   }
43137
43138 }
43139
43140
43141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43142   Dali::Path *arg1 = (Dali::Path *) 0 ;
43143   Dali::Vector3 *arg2 = 0 ;
43144
43145   arg1 = (Dali::Path *)jarg1;
43146   arg2 = (Dali::Vector3 *)jarg2;
43147   if (!arg2) {
43148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43149     return ;
43150   }
43151   {
43152     try {
43153       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43154     } catch (std::out_of_range& e) {
43155       {
43156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43157       };
43158     } catch (std::exception& e) {
43159       {
43160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43161       };
43162     } catch (Dali::DaliException e) {
43163       {
43164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43165       };
43166     } catch (...) {
43167       {
43168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43169       };
43170     }
43171   }
43172
43173 }
43174
43175
43176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43177   Dali::Path *arg1 = (Dali::Path *) 0 ;
43178   float arg2 ;
43179
43180   arg1 = (Dali::Path *)jarg1;
43181   arg2 = (float)jarg2;
43182   {
43183     try {
43184       (arg1)->GenerateControlPoints(arg2);
43185     } catch (std::out_of_range& e) {
43186       {
43187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43188       };
43189     } catch (std::exception& e) {
43190       {
43191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43192       };
43193     } catch (Dali::DaliException e) {
43194       {
43195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43196       };
43197     } catch (...) {
43198       {
43199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43200       };
43201     }
43202   }
43203
43204 }
43205
43206
43207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43208   Dali::Path *arg1 = (Dali::Path *) 0 ;
43209   float arg2 ;
43210   Dali::Vector3 *arg3 = 0 ;
43211   Dali::Vector3 *arg4 = 0 ;
43212
43213   arg1 = (Dali::Path *)jarg1;
43214   arg2 = (float)jarg2;
43215   arg3 = (Dali::Vector3 *)jarg3;
43216   if (!arg3) {
43217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43218     return ;
43219   }
43220   arg4 = (Dali::Vector3 *)jarg4;
43221   if (!arg4) {
43222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43223     return ;
43224   }
43225   {
43226     try {
43227       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43228     } catch (std::out_of_range& e) {
43229       {
43230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43231       };
43232     } catch (std::exception& e) {
43233       {
43234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43235       };
43236     } catch (Dali::DaliException e) {
43237       {
43238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43239       };
43240     } catch (...) {
43241       {
43242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43243       };
43244     }
43245   }
43246
43247 }
43248
43249
43250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43251   void * jresult ;
43252   Dali::Path *arg1 = (Dali::Path *) 0 ;
43253   size_t arg2 ;
43254   Dali::Vector3 *result = 0 ;
43255
43256   arg1 = (Dali::Path *)jarg1;
43257   arg2 = (size_t)jarg2;
43258   {
43259     try {
43260       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43261     } catch (std::out_of_range& e) {
43262       {
43263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43264       };
43265     } catch (std::exception& e) {
43266       {
43267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43268       };
43269     } catch (Dali::DaliException e) {
43270       {
43271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43272       };
43273     } catch (...) {
43274       {
43275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43276       };
43277     }
43278   }
43279
43280   jresult = (void *)result;
43281   return jresult;
43282 }
43283
43284
43285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43286   void * jresult ;
43287   Dali::Path *arg1 = (Dali::Path *) 0 ;
43288   size_t arg2 ;
43289   Dali::Vector3 *result = 0 ;
43290
43291   arg1 = (Dali::Path *)jarg1;
43292   arg2 = (size_t)jarg2;
43293   {
43294     try {
43295       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43296     } catch (std::out_of_range& e) {
43297       {
43298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43299       };
43300     } catch (std::exception& e) {
43301       {
43302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43303       };
43304     } catch (Dali::DaliException e) {
43305       {
43306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43307       };
43308     } catch (...) {
43309       {
43310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43311       };
43312     }
43313   }
43314
43315   jresult = (void *)result;
43316   return jresult;
43317 }
43318
43319
43320 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43321   unsigned long jresult ;
43322   Dali::Path *arg1 = (Dali::Path *) 0 ;
43323   size_t result;
43324
43325   arg1 = (Dali::Path *)jarg1;
43326   {
43327     try {
43328       result = ((Dali::Path const *)arg1)->GetPointCount();
43329     } catch (std::out_of_range& e) {
43330       {
43331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43332       };
43333     } catch (std::exception& e) {
43334       {
43335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43336       };
43337     } catch (Dali::DaliException e) {
43338       {
43339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43340       };
43341     } catch (...) {
43342       {
43343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43344       };
43345     }
43346   }
43347
43348   jresult = (unsigned long)result;
43349   return jresult;
43350 }
43351
43352
43353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43354   void * jresult ;
43355   float arg1 ;
43356   Dali::TimePeriod *result = 0 ;
43357
43358   arg1 = (float)jarg1;
43359   {
43360     try {
43361       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43362     } catch (std::out_of_range& e) {
43363       {
43364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43365       };
43366     } catch (std::exception& e) {
43367       {
43368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43369       };
43370     } catch (Dali::DaliException e) {
43371       {
43372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43373       };
43374     } catch (...) {
43375       {
43376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43377       };
43378     }
43379   }
43380
43381   jresult = (void *)result;
43382   return jresult;
43383 }
43384
43385
43386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43387   void * jresult ;
43388   float arg1 ;
43389   float arg2 ;
43390   Dali::TimePeriod *result = 0 ;
43391
43392   arg1 = (float)jarg1;
43393   arg2 = (float)jarg2;
43394   {
43395     try {
43396       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43397     } catch (std::out_of_range& e) {
43398       {
43399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43400       };
43401     } catch (std::exception& e) {
43402       {
43403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43404       };
43405     } catch (Dali::DaliException e) {
43406       {
43407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43408       };
43409     } catch (...) {
43410       {
43411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43412       };
43413     }
43414   }
43415
43416   jresult = (void *)result;
43417   return jresult;
43418 }
43419
43420
43421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
43422   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43423
43424   arg1 = (Dali::TimePeriod *)jarg1;
43425   {
43426     try {
43427       delete arg1;
43428     } catch (std::out_of_range& e) {
43429       {
43430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43431       };
43432     } catch (std::exception& e) {
43433       {
43434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43435       };
43436     } catch (Dali::DaliException e) {
43437       {
43438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43439       };
43440     } catch (...) {
43441       {
43442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43443       };
43444     }
43445   }
43446
43447 }
43448
43449
43450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
43451   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43452   float arg2 ;
43453
43454   arg1 = (Dali::TimePeriod *)jarg1;
43455   arg2 = (float)jarg2;
43456   if (arg1) (arg1)->delaySeconds = arg2;
43457 }
43458
43459
43460 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
43461   float jresult ;
43462   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43463   float result;
43464
43465   arg1 = (Dali::TimePeriod *)jarg1;
43466   result = (float) ((arg1)->delaySeconds);
43467   jresult = result;
43468   return jresult;
43469 }
43470
43471
43472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
43473   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43474   float arg2 ;
43475
43476   arg1 = (Dali::TimePeriod *)jarg1;
43477   arg2 = (float)jarg2;
43478   if (arg1) (arg1)->durationSeconds = arg2;
43479 }
43480
43481
43482 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
43483   float jresult ;
43484   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43485   float result;
43486
43487   arg1 = (Dali::TimePeriod *)jarg1;
43488   result = (float) ((arg1)->durationSeconds);
43489   jresult = result;
43490   return jresult;
43491 }
43492
43493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
43494   int jresult ;
43495   int result;
43496
43497   result = (int)Dali::LinearConstrainer::Property::VALUE;
43498   jresult = (int)result;
43499   return jresult;
43500 }
43501
43502
43503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
43504   int jresult ;
43505   int result;
43506
43507   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
43508   jresult = (int)result;
43509   return jresult;
43510 }
43511
43512
43513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
43514   void * jresult ;
43515   Dali::LinearConstrainer::Property *result = 0 ;
43516
43517   {
43518     try {
43519       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
43520     } catch (std::out_of_range& e) {
43521       {
43522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43523       };
43524     } catch (std::exception& e) {
43525       {
43526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43527       };
43528     } catch (Dali::DaliException e) {
43529       {
43530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43531       };
43532     } catch (...) {
43533       {
43534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43535       };
43536     }
43537   }
43538
43539   jresult = (void *)result;
43540   return jresult;
43541 }
43542
43543
43544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
43545   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
43546
43547   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
43548   {
43549     try {
43550       delete arg1;
43551     } catch (std::out_of_range& e) {
43552       {
43553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43554       };
43555     } catch (std::exception& e) {
43556       {
43557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43558       };
43559     } catch (Dali::DaliException e) {
43560       {
43561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43562       };
43563     } catch (...) {
43564       {
43565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43566       };
43567     }
43568   }
43569
43570 }
43571
43572
43573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
43574   void * jresult ;
43575   Dali::LinearConstrainer result;
43576
43577   {
43578     try {
43579       result = Dali::LinearConstrainer::New();
43580     } catch (std::out_of_range& e) {
43581       {
43582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43583       };
43584     } catch (std::exception& e) {
43585       {
43586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43587       };
43588     } catch (Dali::DaliException e) {
43589       {
43590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43591       };
43592     } catch (...) {
43593       {
43594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43595       };
43596     }
43597   }
43598
43599   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43600   return jresult;
43601 }
43602
43603
43604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
43605   void * jresult ;
43606   Dali::BaseHandle arg1 ;
43607   Dali::BaseHandle *argp1 ;
43608   Dali::LinearConstrainer result;
43609
43610   argp1 = (Dali::BaseHandle *)jarg1;
43611   if (!argp1) {
43612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43613     return 0;
43614   }
43615   arg1 = *argp1;
43616   {
43617     try {
43618       result = Dali::LinearConstrainer::DownCast(arg1);
43619     } catch (std::out_of_range& e) {
43620       {
43621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43622       };
43623     } catch (std::exception& e) {
43624       {
43625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43626       };
43627     } catch (Dali::DaliException e) {
43628       {
43629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43630       };
43631     } catch (...) {
43632       {
43633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43634       };
43635     }
43636   }
43637
43638   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43639   return jresult;
43640 }
43641
43642
43643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
43644   void * jresult ;
43645   Dali::LinearConstrainer *result = 0 ;
43646
43647   {
43648     try {
43649       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
43650     } catch (std::out_of_range& e) {
43651       {
43652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43653       };
43654     } catch (std::exception& e) {
43655       {
43656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43657       };
43658     } catch (Dali::DaliException e) {
43659       {
43660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43661       };
43662     } catch (...) {
43663       {
43664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43665       };
43666     }
43667   }
43668
43669   jresult = (void *)result;
43670   return jresult;
43671 }
43672
43673
43674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
43675   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43676
43677   arg1 = (Dali::LinearConstrainer *)jarg1;
43678   {
43679     try {
43680       delete arg1;
43681     } catch (std::out_of_range& e) {
43682       {
43683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43684       };
43685     } catch (std::exception& e) {
43686       {
43687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43688       };
43689     } catch (Dali::DaliException e) {
43690       {
43691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43692       };
43693     } catch (...) {
43694       {
43695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43696       };
43697     }
43698   }
43699
43700 }
43701
43702
43703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
43704   void * jresult ;
43705   Dali::LinearConstrainer *arg1 = 0 ;
43706   Dali::LinearConstrainer *result = 0 ;
43707
43708   arg1 = (Dali::LinearConstrainer *)jarg1;
43709   if (!arg1) {
43710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43711     return 0;
43712   }
43713   {
43714     try {
43715       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
43716     } catch (std::out_of_range& e) {
43717       {
43718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43719       };
43720     } catch (std::exception& e) {
43721       {
43722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43723       };
43724     } catch (Dali::DaliException e) {
43725       {
43726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43727       };
43728     } catch (...) {
43729       {
43730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43731       };
43732     }
43733   }
43734
43735   jresult = (void *)result;
43736   return jresult;
43737 }
43738
43739
43740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
43741   void * jresult ;
43742   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43743   Dali::LinearConstrainer *arg2 = 0 ;
43744   Dali::LinearConstrainer *result = 0 ;
43745
43746   arg1 = (Dali::LinearConstrainer *)jarg1;
43747   arg2 = (Dali::LinearConstrainer *)jarg2;
43748   if (!arg2) {
43749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43750     return 0;
43751   }
43752   {
43753     try {
43754       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
43755     } catch (std::out_of_range& e) {
43756       {
43757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43758       };
43759     } catch (std::exception& e) {
43760       {
43761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43762       };
43763     } catch (Dali::DaliException e) {
43764       {
43765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43766       };
43767     } catch (...) {
43768       {
43769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43770       };
43771     }
43772   }
43773
43774   jresult = (void *)result;
43775   return jresult;
43776 }
43777
43778
43779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
43780   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43781   SwigValueWrapper< Dali::Property > arg2 ;
43782   SwigValueWrapper< Dali::Property > arg3 ;
43783   Dali::Vector2 *arg4 = 0 ;
43784   Dali::Vector2 *arg5 = 0 ;
43785   Dali::Property *argp2 ;
43786   Dali::Property *argp3 ;
43787
43788   arg1 = (Dali::LinearConstrainer *)jarg1;
43789   argp2 = (Dali::Property *)jarg2;
43790   if (!argp2) {
43791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43792     return ;
43793   }
43794   arg2 = *argp2;
43795   argp3 = (Dali::Property *)jarg3;
43796   if (!argp3) {
43797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43798     return ;
43799   }
43800   arg3 = *argp3;
43801   arg4 = (Dali::Vector2 *)jarg4;
43802   if (!arg4) {
43803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43804     return ;
43805   }
43806   arg5 = (Dali::Vector2 *)jarg5;
43807   if (!arg5) {
43808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43809     return ;
43810   }
43811   {
43812     try {
43813       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
43814     } catch (std::out_of_range& e) {
43815       {
43816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43817       };
43818     } catch (std::exception& e) {
43819       {
43820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43821       };
43822     } catch (Dali::DaliException e) {
43823       {
43824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43825       };
43826     } catch (...) {
43827       {
43828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43829       };
43830     }
43831   }
43832
43833 }
43834
43835
43836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
43837   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43838   SwigValueWrapper< Dali::Property > arg2 ;
43839   SwigValueWrapper< Dali::Property > arg3 ;
43840   Dali::Vector2 *arg4 = 0 ;
43841   Dali::Property *argp2 ;
43842   Dali::Property *argp3 ;
43843
43844   arg1 = (Dali::LinearConstrainer *)jarg1;
43845   argp2 = (Dali::Property *)jarg2;
43846   if (!argp2) {
43847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43848     return ;
43849   }
43850   arg2 = *argp2;
43851   argp3 = (Dali::Property *)jarg3;
43852   if (!argp3) {
43853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43854     return ;
43855   }
43856   arg3 = *argp3;
43857   arg4 = (Dali::Vector2 *)jarg4;
43858   if (!arg4) {
43859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43860     return ;
43861   }
43862   {
43863     try {
43864       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
43865     } catch (std::out_of_range& e) {
43866       {
43867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43868       };
43869     } catch (std::exception& e) {
43870       {
43871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43872       };
43873     } catch (Dali::DaliException e) {
43874       {
43875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43876       };
43877     } catch (...) {
43878       {
43879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43880       };
43881     }
43882   }
43883
43884 }
43885
43886
43887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
43888   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43889   Dali::Handle *arg2 = 0 ;
43890
43891   arg1 = (Dali::LinearConstrainer *)jarg1;
43892   arg2 = (Dali::Handle *)jarg2;
43893   if (!arg2) {
43894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
43895     return ;
43896   }
43897   {
43898     try {
43899       (arg1)->Remove(*arg2);
43900     } catch (std::out_of_range& e) {
43901       {
43902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43903       };
43904     } catch (std::exception& e) {
43905       {
43906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43907       };
43908     } catch (Dali::DaliException e) {
43909       {
43910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43911       };
43912     } catch (...) {
43913       {
43914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43915       };
43916     }
43917   }
43918
43919 }
43920
43921
43922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
43923   int jresult ;
43924   int result;
43925
43926   result = (int)Dali::PathConstrainer::Property::FORWARD;
43927   jresult = (int)result;
43928   return jresult;
43929 }
43930
43931
43932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
43933   int jresult ;
43934   int result;
43935
43936   result = (int)Dali::PathConstrainer::Property::POINTS;
43937   jresult = (int)result;
43938   return jresult;
43939 }
43940
43941
43942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
43943   int jresult ;
43944   int result;
43945
43946   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
43947   jresult = (int)result;
43948   return jresult;
43949 }
43950
43951
43952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
43953   void * jresult ;
43954   Dali::PathConstrainer::Property *result = 0 ;
43955
43956   {
43957     try {
43958       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
43959     } catch (std::out_of_range& e) {
43960       {
43961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43962       };
43963     } catch (std::exception& e) {
43964       {
43965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43966       };
43967     } catch (Dali::DaliException e) {
43968       {
43969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43970       };
43971     } catch (...) {
43972       {
43973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43974       };
43975     }
43976   }
43977
43978   jresult = (void *)result;
43979   return jresult;
43980 }
43981
43982
43983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
43984   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
43985
43986   arg1 = (Dali::PathConstrainer::Property *)jarg1;
43987   {
43988     try {
43989       delete arg1;
43990     } catch (std::out_of_range& e) {
43991       {
43992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43993       };
43994     } catch (std::exception& e) {
43995       {
43996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43997       };
43998     } catch (Dali::DaliException e) {
43999       {
44000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44001       };
44002     } catch (...) {
44003       {
44004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44005       };
44006     }
44007   }
44008
44009 }
44010
44011
44012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44013   void * jresult ;
44014   Dali::PathConstrainer result;
44015
44016   {
44017     try {
44018       result = Dali::PathConstrainer::New();
44019     } catch (std::out_of_range& e) {
44020       {
44021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44022       };
44023     } catch (std::exception& e) {
44024       {
44025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44026       };
44027     } catch (Dali::DaliException e) {
44028       {
44029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44030       };
44031     } catch (...) {
44032       {
44033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44034       };
44035     }
44036   }
44037
44038   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44039   return jresult;
44040 }
44041
44042
44043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44044   void * jresult ;
44045   Dali::BaseHandle arg1 ;
44046   Dali::BaseHandle *argp1 ;
44047   Dali::PathConstrainer result;
44048
44049   argp1 = (Dali::BaseHandle *)jarg1;
44050   if (!argp1) {
44051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44052     return 0;
44053   }
44054   arg1 = *argp1;
44055   {
44056     try {
44057       result = Dali::PathConstrainer::DownCast(arg1);
44058     } catch (std::out_of_range& e) {
44059       {
44060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44061       };
44062     } catch (std::exception& e) {
44063       {
44064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44065       };
44066     } catch (Dali::DaliException e) {
44067       {
44068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44069       };
44070     } catch (...) {
44071       {
44072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44073       };
44074     }
44075   }
44076
44077   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44078   return jresult;
44079 }
44080
44081
44082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44083   void * jresult ;
44084   Dali::PathConstrainer *result = 0 ;
44085
44086   {
44087     try {
44088       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44089     } catch (std::out_of_range& e) {
44090       {
44091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44092       };
44093     } catch (std::exception& e) {
44094       {
44095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44096       };
44097     } catch (Dali::DaliException e) {
44098       {
44099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44100       };
44101     } catch (...) {
44102       {
44103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44104       };
44105     }
44106   }
44107
44108   jresult = (void *)result;
44109   return jresult;
44110 }
44111
44112
44113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44114   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44115
44116   arg1 = (Dali::PathConstrainer *)jarg1;
44117   {
44118     try {
44119       delete arg1;
44120     } catch (std::out_of_range& e) {
44121       {
44122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44123       };
44124     } catch (std::exception& e) {
44125       {
44126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44127       };
44128     } catch (Dali::DaliException e) {
44129       {
44130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44131       };
44132     } catch (...) {
44133       {
44134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44135       };
44136     }
44137   }
44138
44139 }
44140
44141
44142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44143   void * jresult ;
44144   Dali::PathConstrainer *arg1 = 0 ;
44145   Dali::PathConstrainer *result = 0 ;
44146
44147   arg1 = (Dali::PathConstrainer *)jarg1;
44148   if (!arg1) {
44149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44150     return 0;
44151   }
44152   {
44153     try {
44154       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44155     } catch (std::out_of_range& e) {
44156       {
44157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44158       };
44159     } catch (std::exception& e) {
44160       {
44161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44162       };
44163     } catch (Dali::DaliException e) {
44164       {
44165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44166       };
44167     } catch (...) {
44168       {
44169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44170       };
44171     }
44172   }
44173
44174   jresult = (void *)result;
44175   return jresult;
44176 }
44177
44178
44179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44180   void * jresult ;
44181   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44182   Dali::PathConstrainer *arg2 = 0 ;
44183   Dali::PathConstrainer *result = 0 ;
44184
44185   arg1 = (Dali::PathConstrainer *)jarg1;
44186   arg2 = (Dali::PathConstrainer *)jarg2;
44187   if (!arg2) {
44188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44189     return 0;
44190   }
44191   {
44192     try {
44193       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44194     } catch (std::out_of_range& e) {
44195       {
44196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44197       };
44198     } catch (std::exception& e) {
44199       {
44200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44201       };
44202     } catch (Dali::DaliException e) {
44203       {
44204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44205       };
44206     } catch (...) {
44207       {
44208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44209       };
44210     }
44211   }
44212
44213   jresult = (void *)result;
44214   return jresult;
44215 }
44216
44217
44218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44219   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44220   SwigValueWrapper< Dali::Property > arg2 ;
44221   SwigValueWrapper< Dali::Property > arg3 ;
44222   Dali::Vector2 *arg4 = 0 ;
44223   Dali::Vector2 *arg5 = 0 ;
44224   Dali::Property *argp2 ;
44225   Dali::Property *argp3 ;
44226
44227   arg1 = (Dali::PathConstrainer *)jarg1;
44228   argp2 = (Dali::Property *)jarg2;
44229   if (!argp2) {
44230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44231     return ;
44232   }
44233   arg2 = *argp2;
44234   argp3 = (Dali::Property *)jarg3;
44235   if (!argp3) {
44236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44237     return ;
44238   }
44239   arg3 = *argp3;
44240   arg4 = (Dali::Vector2 *)jarg4;
44241   if (!arg4) {
44242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44243     return ;
44244   }
44245   arg5 = (Dali::Vector2 *)jarg5;
44246   if (!arg5) {
44247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44248     return ;
44249   }
44250   {
44251     try {
44252       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44253     } catch (std::out_of_range& e) {
44254       {
44255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44256       };
44257     } catch (std::exception& e) {
44258       {
44259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44260       };
44261     } catch (Dali::DaliException e) {
44262       {
44263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44264       };
44265     } catch (...) {
44266       {
44267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44268       };
44269     }
44270   }
44271
44272 }
44273
44274
44275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44276   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44277   SwigValueWrapper< Dali::Property > arg2 ;
44278   SwigValueWrapper< Dali::Property > arg3 ;
44279   Dali::Vector2 *arg4 = 0 ;
44280   Dali::Property *argp2 ;
44281   Dali::Property *argp3 ;
44282
44283   arg1 = (Dali::PathConstrainer *)jarg1;
44284   argp2 = (Dali::Property *)jarg2;
44285   if (!argp2) {
44286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44287     return ;
44288   }
44289   arg2 = *argp2;
44290   argp3 = (Dali::Property *)jarg3;
44291   if (!argp3) {
44292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44293     return ;
44294   }
44295   arg3 = *argp3;
44296   arg4 = (Dali::Vector2 *)jarg4;
44297   if (!arg4) {
44298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44299     return ;
44300   }
44301   {
44302     try {
44303       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44304     } catch (std::out_of_range& e) {
44305       {
44306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44307       };
44308     } catch (std::exception& e) {
44309       {
44310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44311       };
44312     } catch (Dali::DaliException e) {
44313       {
44314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44315       };
44316     } catch (...) {
44317       {
44318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44319       };
44320     }
44321   }
44322
44323 }
44324
44325
44326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44327   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44328   Dali::Handle *arg2 = 0 ;
44329
44330   arg1 = (Dali::PathConstrainer *)jarg1;
44331   arg2 = (Dali::Handle *)jarg2;
44332   if (!arg2) {
44333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44334     return ;
44335   }
44336   {
44337     try {
44338       (arg1)->Remove(*arg2);
44339     } catch (std::out_of_range& e) {
44340       {
44341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44342       };
44343     } catch (std::exception& e) {
44344       {
44345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44346       };
44347     } catch (Dali::DaliException e) {
44348       {
44349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44350       };
44351     } catch (...) {
44352       {
44353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44354       };
44355     }
44356   }
44357
44358 }
44359
44360
44361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44362   int jresult ;
44363   Dali::FittingMode::Type result;
44364
44365   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44366   jresult = (int)result;
44367   return jresult;
44368 }
44369
44370
44371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44372   int jresult ;
44373   Dali::SamplingMode::Type result;
44374
44375   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44376   jresult = (int)result;
44377   return jresult;
44378 }
44379
44380
44381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
44382   unsigned int jresult ;
44383   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44384   bool result;
44385
44386   arg1 = (Dali::NativeImageInterface *)jarg1;
44387   {
44388     try {
44389       result = (bool)(arg1)->CreateResource();
44390     } catch (std::out_of_range& e) {
44391       {
44392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44393       };
44394     } catch (std::exception& e) {
44395       {
44396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44397       };
44398     } catch (Dali::DaliException e) {
44399       {
44400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44401       };
44402     } catch (...) {
44403       {
44404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44405       };
44406     }
44407   }
44408
44409   jresult = result;
44410   return jresult;
44411 }
44412
44413
44414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
44415   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44416
44417   arg1 = (Dali::NativeImageInterface *)jarg1;
44418   {
44419     try {
44420       (arg1)->DestroyResource();
44421     } catch (std::out_of_range& e) {
44422       {
44423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44424       };
44425     } catch (std::exception& e) {
44426       {
44427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44428       };
44429     } catch (Dali::DaliException e) {
44430       {
44431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44432       };
44433     } catch (...) {
44434       {
44435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44436       };
44437     }
44438   }
44439
44440 }
44441
44442
44443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
44444   unsigned int jresult ;
44445   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44446   unsigned int result;
44447
44448   arg1 = (Dali::NativeImageInterface *)jarg1;
44449   {
44450     try {
44451       result = (unsigned int)(arg1)->TargetTexture();
44452     } catch (std::out_of_range& e) {
44453       {
44454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44455       };
44456     } catch (std::exception& e) {
44457       {
44458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44459       };
44460     } catch (Dali::DaliException e) {
44461       {
44462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44463       };
44464     } catch (...) {
44465       {
44466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44467       };
44468     }
44469   }
44470
44471   jresult = result;
44472   return jresult;
44473 }
44474
44475
44476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
44477   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44478
44479   arg1 = (Dali::NativeImageInterface *)jarg1;
44480   {
44481     try {
44482       (arg1)->PrepareTexture();
44483     } catch (std::out_of_range& e) {
44484       {
44485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44486       };
44487     } catch (std::exception& e) {
44488       {
44489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44490       };
44491     } catch (Dali::DaliException e) {
44492       {
44493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44494       };
44495     } catch (...) {
44496       {
44497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44498       };
44499     }
44500   }
44501
44502 }
44503
44504
44505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
44506   unsigned int jresult ;
44507   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44508   unsigned int result;
44509
44510   arg1 = (Dali::NativeImageInterface *)jarg1;
44511   {
44512     try {
44513       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
44514     } catch (std::out_of_range& e) {
44515       {
44516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44517       };
44518     } catch (std::exception& e) {
44519       {
44520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44521       };
44522     } catch (Dali::DaliException e) {
44523       {
44524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44525       };
44526     } catch (...) {
44527       {
44528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44529       };
44530     }
44531   }
44532
44533   jresult = result;
44534   return jresult;
44535 }
44536
44537
44538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
44539   unsigned int jresult ;
44540   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44541   unsigned int result;
44542
44543   arg1 = (Dali::NativeImageInterface *)jarg1;
44544   {
44545     try {
44546       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
44547     } catch (std::out_of_range& e) {
44548       {
44549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44550       };
44551     } catch (std::exception& e) {
44552       {
44553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44554       };
44555     } catch (Dali::DaliException e) {
44556       {
44557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44558       };
44559     } catch (...) {
44560       {
44561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44562       };
44563     }
44564   }
44565
44566   jresult = result;
44567   return jresult;
44568 }
44569
44570
44571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
44572   unsigned int jresult ;
44573   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44574   bool result;
44575
44576   arg1 = (Dali::NativeImageInterface *)jarg1;
44577   {
44578     try {
44579       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
44580     } catch (std::out_of_range& e) {
44581       {
44582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44583       };
44584     } catch (std::exception& e) {
44585       {
44586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44587       };
44588     } catch (Dali::DaliException e) {
44589       {
44590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44591       };
44592     } catch (...) {
44593       {
44594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44595       };
44596     }
44597   }
44598
44599   jresult = result;
44600   return jresult;
44601 }
44602
44603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
44604   int jresult ;
44605   int result;
44606
44607   result = (int)Dali::CameraActor::Property::TYPE;
44608   jresult = (int)result;
44609   return jresult;
44610 }
44611
44612
44613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
44614   int jresult ;
44615   int result;
44616
44617   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
44618   jresult = (int)result;
44619   return jresult;
44620 }
44621
44622
44623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
44624   int jresult ;
44625   int result;
44626
44627   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
44628   jresult = (int)result;
44629   return jresult;
44630 }
44631
44632
44633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
44634   int jresult ;
44635   int result;
44636
44637   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
44638   jresult = (int)result;
44639   return jresult;
44640 }
44641
44642
44643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
44644   int jresult ;
44645   int result;
44646
44647   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
44648   jresult = (int)result;
44649   return jresult;
44650 }
44651
44652
44653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
44654   int jresult ;
44655   int result;
44656
44657   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
44658   jresult = (int)result;
44659   return jresult;
44660 }
44661
44662
44663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
44664   int jresult ;
44665   int result;
44666
44667   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
44668   jresult = (int)result;
44669   return jresult;
44670 }
44671
44672
44673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
44674   int jresult ;
44675   int result;
44676
44677   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
44678   jresult = (int)result;
44679   return jresult;
44680 }
44681
44682
44683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
44684   int jresult ;
44685   int result;
44686
44687   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
44688   jresult = (int)result;
44689   return jresult;
44690 }
44691
44692
44693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
44694   int jresult ;
44695   int result;
44696
44697   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
44698   jresult = (int)result;
44699   return jresult;
44700 }
44701
44702
44703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
44704   int jresult ;
44705   int result;
44706
44707   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
44708   jresult = (int)result;
44709   return jresult;
44710 }
44711
44712
44713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
44714   int jresult ;
44715   int result;
44716
44717   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
44718   jresult = (int)result;
44719   return jresult;
44720 }
44721
44722
44723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
44724   int jresult ;
44725   int result;
44726
44727   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
44728   jresult = (int)result;
44729   return jresult;
44730 }
44731
44732
44733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
44734   int jresult ;
44735   int result;
44736
44737   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
44738   jresult = (int)result;
44739   return jresult;
44740 }
44741
44742
44743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
44744   void * jresult ;
44745   Dali::CameraActor::Property *result = 0 ;
44746
44747   {
44748     try {
44749       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
44750     } catch (std::out_of_range& e) {
44751       {
44752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44753       };
44754     } catch (std::exception& e) {
44755       {
44756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44757       };
44758     } catch (Dali::DaliException e) {
44759       {
44760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44761       };
44762     } catch (...) {
44763       {
44764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44765       };
44766     }
44767   }
44768
44769   jresult = (void *)result;
44770   return jresult;
44771 }
44772
44773
44774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
44775   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
44776
44777   arg1 = (Dali::CameraActor::Property *)jarg1;
44778   {
44779     try {
44780       delete arg1;
44781     } catch (std::out_of_range& e) {
44782       {
44783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44784       };
44785     } catch (std::exception& e) {
44786       {
44787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44788       };
44789     } catch (Dali::DaliException e) {
44790       {
44791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44792       };
44793     } catch (...) {
44794       {
44795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44796       };
44797     }
44798   }
44799
44800 }
44801
44802
44803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
44804   void * jresult ;
44805   Dali::CameraActor *result = 0 ;
44806
44807   {
44808     try {
44809       result = (Dali::CameraActor *)new Dali::CameraActor();
44810     } catch (std::out_of_range& e) {
44811       {
44812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44813       };
44814     } catch (std::exception& e) {
44815       {
44816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44817       };
44818     } catch (Dali::DaliException e) {
44819       {
44820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44821       };
44822     } catch (...) {
44823       {
44824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44825       };
44826     }
44827   }
44828
44829   jresult = (void *)result;
44830   return jresult;
44831 }
44832
44833
44834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
44835   void * jresult ;
44836   Dali::CameraActor result;
44837
44838   {
44839     try {
44840       result = Dali::CameraActor::New();
44841     } catch (std::out_of_range& e) {
44842       {
44843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44844       };
44845     } catch (std::exception& e) {
44846       {
44847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44848       };
44849     } catch (Dali::DaliException e) {
44850       {
44851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44852       };
44853     } catch (...) {
44854       {
44855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44856       };
44857     }
44858   }
44859
44860   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44861   return jresult;
44862 }
44863
44864
44865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
44866   void * jresult ;
44867   Dali::Size *arg1 = 0 ;
44868   Dali::CameraActor result;
44869
44870   arg1 = (Dali::Size *)jarg1;
44871   if (!arg1) {
44872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44873     return 0;
44874   }
44875   {
44876     try {
44877       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
44878     } catch (std::out_of_range& e) {
44879       {
44880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44881       };
44882     } catch (std::exception& e) {
44883       {
44884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44885       };
44886     } catch (Dali::DaliException e) {
44887       {
44888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44889       };
44890     } catch (...) {
44891       {
44892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44893       };
44894     }
44895   }
44896
44897   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44898   return jresult;
44899 }
44900
44901
44902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
44903   void * jresult ;
44904   Dali::BaseHandle arg1 ;
44905   Dali::BaseHandle *argp1 ;
44906   Dali::CameraActor result;
44907
44908   argp1 = (Dali::BaseHandle *)jarg1;
44909   if (!argp1) {
44910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44911     return 0;
44912   }
44913   arg1 = *argp1;
44914   {
44915     try {
44916       result = Dali::CameraActor::DownCast(arg1);
44917     } catch (std::out_of_range& e) {
44918       {
44919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44920       };
44921     } catch (std::exception& e) {
44922       {
44923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44924       };
44925     } catch (Dali::DaliException e) {
44926       {
44927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44928       };
44929     } catch (...) {
44930       {
44931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44932       };
44933     }
44934   }
44935
44936   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44937   return jresult;
44938 }
44939
44940
44941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
44942   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44943
44944   arg1 = (Dali::CameraActor *)jarg1;
44945   {
44946     try {
44947       delete arg1;
44948     } catch (std::out_of_range& e) {
44949       {
44950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44951       };
44952     } catch (std::exception& e) {
44953       {
44954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44955       };
44956     } catch (Dali::DaliException e) {
44957       {
44958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44959       };
44960     } catch (...) {
44961       {
44962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44963       };
44964     }
44965   }
44966
44967 }
44968
44969
44970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
44971   void * jresult ;
44972   Dali::CameraActor *arg1 = 0 ;
44973   Dali::CameraActor *result = 0 ;
44974
44975   arg1 = (Dali::CameraActor *)jarg1;
44976   if (!arg1) {
44977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44978     return 0;
44979   }
44980   {
44981     try {
44982       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
44983     } catch (std::out_of_range& e) {
44984       {
44985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44986       };
44987     } catch (std::exception& e) {
44988       {
44989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44990       };
44991     } catch (Dali::DaliException e) {
44992       {
44993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44994       };
44995     } catch (...) {
44996       {
44997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44998       };
44999     }
45000   }
45001
45002   jresult = (void *)result;
45003   return jresult;
45004 }
45005
45006
45007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
45008   void * jresult ;
45009   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45010   Dali::CameraActor *arg2 = 0 ;
45011   Dali::CameraActor *result = 0 ;
45012
45013   arg1 = (Dali::CameraActor *)jarg1;
45014   arg2 = (Dali::CameraActor *)jarg2;
45015   if (!arg2) {
45016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
45017     return 0;
45018   }
45019   {
45020     try {
45021       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
45022     } catch (std::out_of_range& e) {
45023       {
45024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45025       };
45026     } catch (std::exception& e) {
45027       {
45028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45029       };
45030     } catch (Dali::DaliException e) {
45031       {
45032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45033       };
45034     } catch (...) {
45035       {
45036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45037       };
45038     }
45039   }
45040
45041   jresult = (void *)result;
45042   return jresult;
45043 }
45044
45045
45046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
45047   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45048   Dali::Camera::Type arg2 ;
45049
45050   arg1 = (Dali::CameraActor *)jarg1;
45051   arg2 = (Dali::Camera::Type)jarg2;
45052   {
45053     try {
45054       (arg1)->SetType(arg2);
45055     } catch (std::out_of_range& e) {
45056       {
45057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45058       };
45059     } catch (std::exception& e) {
45060       {
45061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45062       };
45063     } catch (Dali::DaliException e) {
45064       {
45065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45066       };
45067     } catch (...) {
45068       {
45069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45070       };
45071     }
45072   }
45073
45074 }
45075
45076
45077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
45078   int jresult ;
45079   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45080   Dali::Camera::Type result;
45081
45082   arg1 = (Dali::CameraActor *)jarg1;
45083   {
45084     try {
45085       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
45086     } catch (std::out_of_range& e) {
45087       {
45088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45089       };
45090     } catch (std::exception& e) {
45091       {
45092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45093       };
45094     } catch (Dali::DaliException e) {
45095       {
45096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45097       };
45098     } catch (...) {
45099       {
45100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45101       };
45102     }
45103   }
45104
45105   jresult = (int)result;
45106   return jresult;
45107 }
45108
45109
45110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
45111   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45112   Dali::Camera::ProjectionMode arg2 ;
45113
45114   arg1 = (Dali::CameraActor *)jarg1;
45115   arg2 = (Dali::Camera::ProjectionMode)jarg2;
45116   {
45117     try {
45118       (arg1)->SetProjectionMode(arg2);
45119     } catch (std::out_of_range& e) {
45120       {
45121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45122       };
45123     } catch (std::exception& e) {
45124       {
45125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45126       };
45127     } catch (Dali::DaliException e) {
45128       {
45129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45130       };
45131     } catch (...) {
45132       {
45133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45134       };
45135     }
45136   }
45137
45138 }
45139
45140
45141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
45142   int jresult ;
45143   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45144   Dali::Camera::ProjectionMode result;
45145
45146   arg1 = (Dali::CameraActor *)jarg1;
45147   {
45148     try {
45149       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
45150     } catch (std::out_of_range& e) {
45151       {
45152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45153       };
45154     } catch (std::exception& e) {
45155       {
45156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45157       };
45158     } catch (Dali::DaliException e) {
45159       {
45160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45161       };
45162     } catch (...) {
45163       {
45164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45165       };
45166     }
45167   }
45168
45169   jresult = (int)result;
45170   return jresult;
45171 }
45172
45173
45174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
45175   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45176   float arg2 ;
45177
45178   arg1 = (Dali::CameraActor *)jarg1;
45179   arg2 = (float)jarg2;
45180   {
45181     try {
45182       (arg1)->SetFieldOfView(arg2);
45183     } catch (std::out_of_range& e) {
45184       {
45185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45186       };
45187     } catch (std::exception& e) {
45188       {
45189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45190       };
45191     } catch (Dali::DaliException e) {
45192       {
45193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45194       };
45195     } catch (...) {
45196       {
45197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45198       };
45199     }
45200   }
45201
45202 }
45203
45204
45205 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
45206   float jresult ;
45207   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45208   float result;
45209
45210   arg1 = (Dali::CameraActor *)jarg1;
45211   {
45212     try {
45213       result = (float)(arg1)->GetFieldOfView();
45214     } catch (std::out_of_range& e) {
45215       {
45216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45217       };
45218     } catch (std::exception& e) {
45219       {
45220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45221       };
45222     } catch (Dali::DaliException e) {
45223       {
45224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45225       };
45226     } catch (...) {
45227       {
45228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45229       };
45230     }
45231   }
45232
45233   jresult = result;
45234   return jresult;
45235 }
45236
45237
45238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
45239   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45240   float arg2 ;
45241
45242   arg1 = (Dali::CameraActor *)jarg1;
45243   arg2 = (float)jarg2;
45244   {
45245     try {
45246       (arg1)->SetAspectRatio(arg2);
45247     } catch (std::out_of_range& e) {
45248       {
45249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45250       };
45251     } catch (std::exception& e) {
45252       {
45253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45254       };
45255     } catch (Dali::DaliException e) {
45256       {
45257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45258       };
45259     } catch (...) {
45260       {
45261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45262       };
45263     }
45264   }
45265
45266 }
45267
45268
45269 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
45270   float jresult ;
45271   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45272   float result;
45273
45274   arg1 = (Dali::CameraActor *)jarg1;
45275   {
45276     try {
45277       result = (float)(arg1)->GetAspectRatio();
45278     } catch (std::out_of_range& e) {
45279       {
45280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45281       };
45282     } catch (std::exception& e) {
45283       {
45284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45285       };
45286     } catch (Dali::DaliException e) {
45287       {
45288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45289       };
45290     } catch (...) {
45291       {
45292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45293       };
45294     }
45295   }
45296
45297   jresult = result;
45298   return jresult;
45299 }
45300
45301
45302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
45303   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45304   float arg2 ;
45305
45306   arg1 = (Dali::CameraActor *)jarg1;
45307   arg2 = (float)jarg2;
45308   {
45309     try {
45310       (arg1)->SetNearClippingPlane(arg2);
45311     } catch (std::out_of_range& e) {
45312       {
45313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45314       };
45315     } catch (std::exception& e) {
45316       {
45317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45318       };
45319     } catch (Dali::DaliException e) {
45320       {
45321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45322       };
45323     } catch (...) {
45324       {
45325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45326       };
45327     }
45328   }
45329
45330 }
45331
45332
45333 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
45334   float jresult ;
45335   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45336   float result;
45337
45338   arg1 = (Dali::CameraActor *)jarg1;
45339   {
45340     try {
45341       result = (float)(arg1)->GetNearClippingPlane();
45342     } catch (std::out_of_range& e) {
45343       {
45344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45345       };
45346     } catch (std::exception& e) {
45347       {
45348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45349       };
45350     } catch (Dali::DaliException e) {
45351       {
45352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45353       };
45354     } catch (...) {
45355       {
45356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45357       };
45358     }
45359   }
45360
45361   jresult = result;
45362   return jresult;
45363 }
45364
45365
45366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
45367   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45368   float arg2 ;
45369
45370   arg1 = (Dali::CameraActor *)jarg1;
45371   arg2 = (float)jarg2;
45372   {
45373     try {
45374       (arg1)->SetFarClippingPlane(arg2);
45375     } catch (std::out_of_range& e) {
45376       {
45377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45378       };
45379     } catch (std::exception& e) {
45380       {
45381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45382       };
45383     } catch (Dali::DaliException e) {
45384       {
45385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45386       };
45387     } catch (...) {
45388       {
45389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45390       };
45391     }
45392   }
45393
45394 }
45395
45396
45397 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
45398   float jresult ;
45399   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45400   float result;
45401
45402   arg1 = (Dali::CameraActor *)jarg1;
45403   {
45404     try {
45405       result = (float)(arg1)->GetFarClippingPlane();
45406     } catch (std::out_of_range& e) {
45407       {
45408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45409       };
45410     } catch (std::exception& e) {
45411       {
45412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45413       };
45414     } catch (Dali::DaliException e) {
45415       {
45416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45417       };
45418     } catch (...) {
45419       {
45420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45421       };
45422     }
45423   }
45424
45425   jresult = result;
45426   return jresult;
45427 }
45428
45429
45430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
45431   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45432   Dali::Vector3 *arg2 = 0 ;
45433
45434   arg1 = (Dali::CameraActor *)jarg1;
45435   arg2 = (Dali::Vector3 *)jarg2;
45436   if (!arg2) {
45437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
45438     return ;
45439   }
45440   {
45441     try {
45442       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
45443     } catch (std::out_of_range& e) {
45444       {
45445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45446       };
45447     } catch (std::exception& e) {
45448       {
45449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45450       };
45451     } catch (Dali::DaliException e) {
45452       {
45453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45454       };
45455     } catch (...) {
45456       {
45457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45458       };
45459     }
45460   }
45461
45462 }
45463
45464
45465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
45466   void * jresult ;
45467   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45468   Dali::Vector3 result;
45469
45470   arg1 = (Dali::CameraActor *)jarg1;
45471   {
45472     try {
45473       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
45474     } catch (std::out_of_range& e) {
45475       {
45476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45477       };
45478     } catch (std::exception& e) {
45479       {
45480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45481       };
45482     } catch (Dali::DaliException e) {
45483       {
45484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45485       };
45486     } catch (...) {
45487       {
45488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45489       };
45490     }
45491   }
45492
45493   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
45494   return jresult;
45495 }
45496
45497
45498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
45499   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45500   bool arg2 ;
45501
45502   arg1 = (Dali::CameraActor *)jarg1;
45503   arg2 = jarg2 ? true : false;
45504   {
45505     try {
45506       (arg1)->SetInvertYAxis(arg2);
45507     } catch (std::out_of_range& e) {
45508       {
45509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45510       };
45511     } catch (std::exception& e) {
45512       {
45513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45514       };
45515     } catch (Dali::DaliException e) {
45516       {
45517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45518       };
45519     } catch (...) {
45520       {
45521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45522       };
45523     }
45524   }
45525
45526 }
45527
45528
45529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
45530   unsigned int jresult ;
45531   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45532   bool result;
45533
45534   arg1 = (Dali::CameraActor *)jarg1;
45535   {
45536     try {
45537       result = (bool)(arg1)->GetInvertYAxis();
45538     } catch (std::out_of_range& e) {
45539       {
45540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45541       };
45542     } catch (std::exception& e) {
45543       {
45544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45545       };
45546     } catch (Dali::DaliException e) {
45547       {
45548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45549       };
45550     } catch (...) {
45551       {
45552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45553       };
45554     }
45555   }
45556
45557   jresult = result;
45558   return jresult;
45559 }
45560
45561
45562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
45563   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45564   Dali::Size *arg2 = 0 ;
45565
45566   arg1 = (Dali::CameraActor *)jarg1;
45567   arg2 = (Dali::Size *)jarg2;
45568   if (!arg2) {
45569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45570     return ;
45571   }
45572   {
45573     try {
45574       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
45575     } catch (std::out_of_range& e) {
45576       {
45577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45578       };
45579     } catch (std::exception& e) {
45580       {
45581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45582       };
45583     } catch (Dali::DaliException e) {
45584       {
45585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45586       };
45587     } catch (...) {
45588       {
45589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45590       };
45591     }
45592   }
45593
45594 }
45595
45596
45597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
45598   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45599   Dali::Size *arg2 = 0 ;
45600
45601   arg1 = (Dali::CameraActor *)jarg1;
45602   arg2 = (Dali::Size *)jarg2;
45603   if (!arg2) {
45604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45605     return ;
45606   }
45607   {
45608     try {
45609       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
45610     } catch (std::out_of_range& e) {
45611       {
45612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45613       };
45614     } catch (std::exception& e) {
45615       {
45616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45617       };
45618     } catch (Dali::DaliException e) {
45619       {
45620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45621       };
45622     } catch (...) {
45623       {
45624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45625       };
45626     }
45627   }
45628
45629 }
45630
45631
45632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
45633   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45634   float arg2 ;
45635   float arg3 ;
45636   float arg4 ;
45637   float arg5 ;
45638   float arg6 ;
45639   float arg7 ;
45640
45641   arg1 = (Dali::CameraActor *)jarg1;
45642   arg2 = (float)jarg2;
45643   arg3 = (float)jarg3;
45644   arg4 = (float)jarg4;
45645   arg5 = (float)jarg5;
45646   arg6 = (float)jarg6;
45647   arg7 = (float)jarg7;
45648   {
45649     try {
45650       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
45651     } catch (std::out_of_range& e) {
45652       {
45653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45654       };
45655     } catch (std::exception& e) {
45656       {
45657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45658       };
45659     } catch (Dali::DaliException e) {
45660       {
45661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45662       };
45663     } catch (...) {
45664       {
45665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45666       };
45667     }
45668   }
45669
45670 }
45671
45672
45673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
45674   void * jresult ;
45675   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45676
45677   {
45678     try {
45679       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
45680     } catch (std::out_of_range& e) {
45681       {
45682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45683       };
45684     } catch (std::exception& e) {
45685       {
45686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45687       };
45688     } catch (Dali::DaliException e) {
45689       {
45690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45691       };
45692     } catch (...) {
45693       {
45694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45695       };
45696     }
45697   }
45698
45699   jresult = (void *)result;
45700   return jresult;
45701 }
45702
45703
45704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
45705   void * jresult ;
45706   std::string arg1 ;
45707   Dali::Property::Value arg2 ;
45708   Dali::Property::Value *argp2 ;
45709   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45710
45711   if (!jarg1) {
45712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45713     return 0;
45714   }
45715   (&arg1)->assign(jarg1);
45716   argp2 = (Dali::Property::Value *)jarg2;
45717   if (!argp2) {
45718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
45719     return 0;
45720   }
45721   arg2 = *argp2;
45722   {
45723     try {
45724       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
45725     } catch (std::out_of_range& e) {
45726       {
45727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45728       };
45729     } catch (std::exception& e) {
45730       {
45731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45732       };
45733     } catch (Dali::DaliException e) {
45734       {
45735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45736       };
45737     } catch (...) {
45738       {
45739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45740       };
45741     }
45742   }
45743
45744   jresult = (void *)result;
45745   return jresult;
45746 }
45747
45748
45749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
45750   void * jresult ;
45751   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
45752   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45753
45754   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45755   if (!arg1) {
45756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
45757     return 0;
45758   }
45759   {
45760     try {
45761       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);
45762     } catch (std::out_of_range& e) {
45763       {
45764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45765       };
45766     } catch (std::exception& e) {
45767       {
45768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45769       };
45770     } catch (Dali::DaliException e) {
45771       {
45772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45773       };
45774     } catch (...) {
45775       {
45776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45777       };
45778     }
45779   }
45780
45781   jresult = (void *)result;
45782   return jresult;
45783 }
45784
45785
45786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
45787   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45788   std::string *arg2 = 0 ;
45789
45790   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45791   if (!jarg2) {
45792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45793     return ;
45794   }
45795   std::string arg2_str(jarg2);
45796   arg2 = &arg2_str;
45797   if (arg1) (arg1)->first = *arg2;
45798
45799   //argout typemap for const std::string&
45800
45801 }
45802
45803
45804 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
45805   char * jresult ;
45806   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45807   std::string *result = 0 ;
45808
45809   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45810   result = (std::string *) & ((arg1)->first);
45811   jresult = SWIG_csharp_string_callback(result->c_str());
45812   return jresult;
45813 }
45814
45815
45816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
45817   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45818   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
45819
45820   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45821   arg2 = (Dali::Property::Value *)jarg2;
45822   if (arg1) (arg1)->second = *arg2;
45823 }
45824
45825
45826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
45827   void * jresult ;
45828   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45829   Dali::Property::Value *result = 0 ;
45830
45831   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45832   result = (Dali::Property::Value *)& ((arg1)->second);
45833   jresult = (void *)result;
45834   return jresult;
45835 }
45836
45837
45838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
45839   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45840
45841   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45842   {
45843     try {
45844       delete arg1;
45845     } catch (std::out_of_range& e) {
45846       {
45847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45848       };
45849     } catch (std::exception& e) {
45850       {
45851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45852       };
45853     } catch (Dali::DaliException e) {
45854       {
45855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45856       };
45857     } catch (...) {
45858       {
45859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45860       };
45861     }
45862   }
45863
45864 }
45865
45866
45867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
45868   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45869
45870   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45871   {
45872     try {
45873       (arg1)->clear();
45874     } catch (std::out_of_range& e) {
45875       {
45876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45877       };
45878     } catch (std::exception& e) {
45879       {
45880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45881       };
45882     } catch (Dali::DaliException e) {
45883       {
45884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45885       };
45886     } catch (...) {
45887       {
45888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45889       };
45890     }
45891   }
45892
45893 }
45894
45895
45896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
45897   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45898   Dali::TouchPoint *arg2 = 0 ;
45899
45900   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45901   arg2 = (Dali::TouchPoint *)jarg2;
45902   if (!arg2) {
45903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45904     return ;
45905   }
45906   {
45907     try {
45908       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
45909     } catch (std::out_of_range& e) {
45910       {
45911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45912       };
45913     } catch (std::exception& e) {
45914       {
45915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45916       };
45917     } catch (Dali::DaliException e) {
45918       {
45919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45920       };
45921     } catch (...) {
45922       {
45923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45924       };
45925     }
45926   }
45927
45928 }
45929
45930
45931 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
45932   unsigned long jresult ;
45933   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45934   std::vector< Dali::TouchPoint >::size_type result;
45935
45936   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45937   {
45938     try {
45939       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
45940     } catch (std::out_of_range& e) {
45941       {
45942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45943       };
45944     } catch (std::exception& e) {
45945       {
45946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45947       };
45948     } catch (Dali::DaliException e) {
45949       {
45950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45951       };
45952     } catch (...) {
45953       {
45954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45955       };
45956     }
45957   }
45958
45959   jresult = (unsigned long)result;
45960   return jresult;
45961 }
45962
45963
45964 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
45965   unsigned long jresult ;
45966   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45967   std::vector< Dali::TouchPoint >::size_type result;
45968
45969   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45970   {
45971     try {
45972       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
45973     } catch (std::out_of_range& e) {
45974       {
45975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45976       };
45977     } catch (std::exception& e) {
45978       {
45979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45980       };
45981     } catch (Dali::DaliException e) {
45982       {
45983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45984       };
45985     } catch (...) {
45986       {
45987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45988       };
45989     }
45990   }
45991
45992   jresult = (unsigned long)result;
45993   return jresult;
45994 }
45995
45996
45997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
45998   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45999   std::vector< Dali::TouchPoint >::size_type arg2 ;
46000
46001   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46002   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
46003   {
46004     try {
46005       (arg1)->reserve(arg2);
46006     } catch (std::out_of_range& e) {
46007       {
46008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46009       };
46010     } catch (std::exception& e) {
46011       {
46012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46013       };
46014     } catch (Dali::DaliException e) {
46015       {
46016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46017       };
46018     } catch (...) {
46019       {
46020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46021       };
46022     }
46023   }
46024
46025 }
46026
46027
46028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
46029   void * jresult ;
46030   std::vector< Dali::TouchPoint > *result = 0 ;
46031
46032   {
46033     try {
46034       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
46035     } catch (std::out_of_range& e) {
46036       {
46037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46038       };
46039     } catch (std::exception& e) {
46040       {
46041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46042       };
46043     } catch (Dali::DaliException e) {
46044       {
46045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46046       };
46047     } catch (...) {
46048       {
46049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46050       };
46051     }
46052   }
46053
46054   jresult = (void *)result;
46055   return jresult;
46056 }
46057
46058
46059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
46060   void * jresult ;
46061   std::vector< Dali::TouchPoint > *arg1 = 0 ;
46062   std::vector< Dali::TouchPoint > *result = 0 ;
46063
46064   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46065   if (!arg1) {
46066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46067     return 0;
46068   }
46069   {
46070     try {
46071       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
46072     } catch (std::out_of_range& e) {
46073       {
46074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46075       };
46076     } catch (std::exception& e) {
46077       {
46078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46079       };
46080     } catch (Dali::DaliException e) {
46081       {
46082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46083       };
46084     } catch (...) {
46085       {
46086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46087       };
46088     }
46089   }
46090
46091   jresult = (void *)result;
46092   return jresult;
46093 }
46094
46095
46096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
46097   void * jresult ;
46098   int arg1 ;
46099   std::vector< Dali::TouchPoint > *result = 0 ;
46100
46101   arg1 = (int)jarg1;
46102   {
46103     try {
46104       try {
46105         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
46106       }
46107       catch(std::out_of_range &_e) {
46108         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46109         return 0;
46110       }
46111
46112     } catch (std::out_of_range& e) {
46113       {
46114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46115       };
46116     } catch (std::exception& e) {
46117       {
46118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46119       };
46120     } catch (Dali::DaliException e) {
46121       {
46122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46123       };
46124     } catch (...) {
46125       {
46126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46127       };
46128     }
46129   }
46130
46131   jresult = (void *)result;
46132   return jresult;
46133 }
46134
46135
46136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
46137   void * jresult ;
46138   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46139   int arg2 ;
46140   SwigValueWrapper< Dali::TouchPoint > result;
46141
46142   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46143   arg2 = (int)jarg2;
46144   {
46145     try {
46146       try {
46147         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
46148       }
46149       catch(std::out_of_range &_e) {
46150         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46151         return 0;
46152       }
46153
46154     } catch (std::out_of_range& e) {
46155       {
46156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46157       };
46158     } catch (std::exception& e) {
46159       {
46160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46161       };
46162     } catch (Dali::DaliException e) {
46163       {
46164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46165       };
46166     } catch (...) {
46167       {
46168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46169       };
46170     }
46171   }
46172
46173   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
46174   return jresult;
46175 }
46176
46177
46178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
46179   void * jresult ;
46180   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46181   int arg2 ;
46182   Dali::TouchPoint *result = 0 ;
46183
46184   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46185   arg2 = (int)jarg2;
46186   {
46187     try {
46188       try {
46189         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
46190       }
46191       catch(std::out_of_range &_e) {
46192         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46193         return 0;
46194       }
46195
46196     } catch (std::out_of_range& e) {
46197       {
46198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46199       };
46200     } catch (std::exception& e) {
46201       {
46202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46203       };
46204     } catch (Dali::DaliException e) {
46205       {
46206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46207       };
46208     } catch (...) {
46209       {
46210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46211       };
46212     }
46213   }
46214
46215   jresult = (void *)result;
46216   return jresult;
46217 }
46218
46219
46220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
46221   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46222   int arg2 ;
46223   Dali::TouchPoint *arg3 = 0 ;
46224
46225   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46226   arg2 = (int)jarg2;
46227   arg3 = (Dali::TouchPoint *)jarg3;
46228   if (!arg3) {
46229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46230     return ;
46231   }
46232   {
46233     try {
46234       try {
46235         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46236       }
46237       catch(std::out_of_range &_e) {
46238         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46239         return ;
46240       }
46241
46242     } catch (std::out_of_range& e) {
46243       {
46244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46245       };
46246     } catch (std::exception& e) {
46247       {
46248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46249       };
46250     } catch (Dali::DaliException e) {
46251       {
46252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46253       };
46254     } catch (...) {
46255       {
46256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46257       };
46258     }
46259   }
46260
46261 }
46262
46263
46264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
46265   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46266   std::vector< Dali::TouchPoint > *arg2 = 0 ;
46267
46268   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46269   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
46270   if (!arg2) {
46271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46272     return ;
46273   }
46274   {
46275     try {
46276       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
46277     } catch (std::out_of_range& e) {
46278       {
46279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46280       };
46281     } catch (std::exception& e) {
46282       {
46283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46284       };
46285     } catch (Dali::DaliException e) {
46286       {
46287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46288       };
46289     } catch (...) {
46290       {
46291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46292       };
46293     }
46294   }
46295
46296 }
46297
46298
46299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
46300   void * jresult ;
46301   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46302   int arg2 ;
46303   int arg3 ;
46304   std::vector< Dali::TouchPoint > *result = 0 ;
46305
46306   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46307   arg2 = (int)jarg2;
46308   arg3 = (int)jarg3;
46309   {
46310     try {
46311       try {
46312         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
46313       }
46314       catch(std::out_of_range &_e) {
46315         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46316         return 0;
46317       }
46318       catch(std::invalid_argument &_e) {
46319         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46320         return 0;
46321       }
46322
46323     } catch (std::out_of_range& e) {
46324       {
46325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46326       };
46327     } catch (std::exception& e) {
46328       {
46329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46330       };
46331     } catch (Dali::DaliException e) {
46332       {
46333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46334       };
46335     } catch (...) {
46336       {
46337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46338       };
46339     }
46340   }
46341
46342   jresult = (void *)result;
46343   return jresult;
46344 }
46345
46346
46347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
46348   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46349   int arg2 ;
46350   Dali::TouchPoint *arg3 = 0 ;
46351
46352   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46353   arg2 = (int)jarg2;
46354   arg3 = (Dali::TouchPoint *)jarg3;
46355   if (!arg3) {
46356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46357     return ;
46358   }
46359   {
46360     try {
46361       try {
46362         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46363       }
46364       catch(std::out_of_range &_e) {
46365         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46366         return ;
46367       }
46368
46369     } catch (std::out_of_range& e) {
46370       {
46371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46372       };
46373     } catch (std::exception& e) {
46374       {
46375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46376       };
46377     } catch (Dali::DaliException e) {
46378       {
46379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46380       };
46381     } catch (...) {
46382       {
46383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46384       };
46385     }
46386   }
46387
46388 }
46389
46390
46391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
46392   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46393   int arg2 ;
46394   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46395
46396   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46397   arg2 = (int)jarg2;
46398   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46399   if (!arg3) {
46400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46401     return ;
46402   }
46403   {
46404     try {
46405       try {
46406         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46407       }
46408       catch(std::out_of_range &_e) {
46409         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46410         return ;
46411       }
46412
46413     } catch (std::out_of_range& e) {
46414       {
46415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46416       };
46417     } catch (std::exception& e) {
46418       {
46419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46420       };
46421     } catch (Dali::DaliException e) {
46422       {
46423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46424       };
46425     } catch (...) {
46426       {
46427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46428       };
46429     }
46430   }
46431
46432 }
46433
46434
46435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
46436   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46437   int arg2 ;
46438
46439   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46440   arg2 = (int)jarg2;
46441   {
46442     try {
46443       try {
46444         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
46445       }
46446       catch(std::out_of_range &_e) {
46447         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46448         return ;
46449       }
46450
46451     } catch (std::out_of_range& e) {
46452       {
46453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46454       };
46455     } catch (std::exception& e) {
46456       {
46457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46458       };
46459     } catch (Dali::DaliException e) {
46460       {
46461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46462       };
46463     } catch (...) {
46464       {
46465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46466       };
46467     }
46468   }
46469
46470 }
46471
46472
46473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
46474   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46475   int arg2 ;
46476   int arg3 ;
46477
46478   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46479   arg2 = (int)jarg2;
46480   arg3 = (int)jarg3;
46481   {
46482     try {
46483       try {
46484         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
46485       }
46486       catch(std::out_of_range &_e) {
46487         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46488         return ;
46489       }
46490       catch(std::invalid_argument &_e) {
46491         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46492         return ;
46493       }
46494
46495     } catch (std::out_of_range& e) {
46496       {
46497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46498       };
46499     } catch (std::exception& e) {
46500       {
46501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46502       };
46503     } catch (Dali::DaliException e) {
46504       {
46505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46506       };
46507     } catch (...) {
46508       {
46509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46510       };
46511     }
46512   }
46513
46514 }
46515
46516
46517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
46518   void * jresult ;
46519   Dali::TouchPoint *arg1 = 0 ;
46520   int arg2 ;
46521   std::vector< Dali::TouchPoint > *result = 0 ;
46522
46523   arg1 = (Dali::TouchPoint *)jarg1;
46524   if (!arg1) {
46525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46526     return 0;
46527   }
46528   arg2 = (int)jarg2;
46529   {
46530     try {
46531       try {
46532         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
46533       }
46534       catch(std::out_of_range &_e) {
46535         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46536         return 0;
46537       }
46538
46539     } catch (std::out_of_range& e) {
46540       {
46541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46542       };
46543     } catch (std::exception& e) {
46544       {
46545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46546       };
46547     } catch (Dali::DaliException e) {
46548       {
46549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46550       };
46551     } catch (...) {
46552       {
46553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46554       };
46555     }
46556   }
46557
46558   jresult = (void *)result;
46559   return jresult;
46560 }
46561
46562
46563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
46564   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46565
46566   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46567   {
46568     try {
46569       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
46570     } catch (std::out_of_range& e) {
46571       {
46572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46573       };
46574     } catch (std::exception& e) {
46575       {
46576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46577       };
46578     } catch (Dali::DaliException e) {
46579       {
46580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46581       };
46582     } catch (...) {
46583       {
46584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46585       };
46586     }
46587   }
46588
46589 }
46590
46591
46592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
46593   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46594   int arg2 ;
46595   int arg3 ;
46596
46597   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46598   arg2 = (int)jarg2;
46599   arg3 = (int)jarg3;
46600   {
46601     try {
46602       try {
46603         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
46604       }
46605       catch(std::out_of_range &_e) {
46606         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46607         return ;
46608       }
46609       catch(std::invalid_argument &_e) {
46610         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46611         return ;
46612       }
46613
46614     } catch (std::out_of_range& e) {
46615       {
46616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46617       };
46618     } catch (std::exception& e) {
46619       {
46620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46621       };
46622     } catch (Dali::DaliException e) {
46623       {
46624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46625       };
46626     } catch (...) {
46627       {
46628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46629       };
46630     }
46631   }
46632
46633 }
46634
46635
46636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
46637   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46638   int arg2 ;
46639   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46640
46641   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46642   arg2 = (int)jarg2;
46643   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46644   if (!arg3) {
46645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46646     return ;
46647   }
46648   {
46649     try {
46650       try {
46651         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46652       }
46653       catch(std::out_of_range &_e) {
46654         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46655         return ;
46656       }
46657
46658     } catch (std::out_of_range& e) {
46659       {
46660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46661       };
46662     } catch (std::exception& e) {
46663       {
46664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46665       };
46666     } catch (Dali::DaliException e) {
46667       {
46668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46669       };
46670     } catch (...) {
46671       {
46672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46673       };
46674     }
46675   }
46676
46677 }
46678
46679
46680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
46681   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46682
46683   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46684   {
46685     try {
46686       delete arg1;
46687     } catch (std::out_of_range& e) {
46688       {
46689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46690       };
46691     } catch (std::exception& e) {
46692       {
46693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46694       };
46695     } catch (Dali::DaliException e) {
46696       {
46697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46698       };
46699     } catch (...) {
46700       {
46701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46702       };
46703     }
46704   }
46705
46706 }
46707
46708
46709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
46710   void * jresult ;
46711   Dali::Rect< int > *result = 0 ;
46712
46713   {
46714     try {
46715       result = (Dali::Rect< int > *)new Dali::Rect< int >();
46716     } catch (std::out_of_range& e) {
46717       {
46718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46719       };
46720     } catch (std::exception& e) {
46721       {
46722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46723       };
46724     } catch (Dali::DaliException e) {
46725       {
46726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46727       };
46728     } catch (...) {
46729       {
46730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46731       };
46732     }
46733   }
46734
46735   jresult = (void *)result;
46736   return jresult;
46737 }
46738
46739
46740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
46741   void * jresult ;
46742   int arg1 ;
46743   int arg2 ;
46744   int arg3 ;
46745   int arg4 ;
46746   Dali::Rect< int > *result = 0 ;
46747
46748   arg1 = (int)jarg1;
46749   arg2 = (int)jarg2;
46750   arg3 = (int)jarg3;
46751   arg4 = (int)jarg4;
46752   {
46753     try {
46754       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
46755     } catch (std::out_of_range& e) {
46756       {
46757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46758       };
46759     } catch (std::exception& e) {
46760       {
46761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46762       };
46763     } catch (Dali::DaliException e) {
46764       {
46765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46766       };
46767     } catch (...) {
46768       {
46769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46770       };
46771     }
46772   }
46773
46774   jresult = (void *)result;
46775   return jresult;
46776 }
46777
46778
46779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
46780   void * jresult ;
46781   Dali::Rect< int > *arg1 = 0 ;
46782   Dali::Rect< int > *result = 0 ;
46783
46784   arg1 = (Dali::Rect< int > *)jarg1;
46785   if (!arg1) {
46786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46787     return 0;
46788   }
46789   {
46790     try {
46791       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
46792     } catch (std::out_of_range& e) {
46793       {
46794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46795       };
46796     } catch (std::exception& e) {
46797       {
46798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46799       };
46800     } catch (Dali::DaliException e) {
46801       {
46802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46803       };
46804     } catch (...) {
46805       {
46806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46807       };
46808     }
46809   }
46810
46811   jresult = (void *)result;
46812   return jresult;
46813 }
46814
46815
46816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
46817   void * jresult ;
46818   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46819   Dali::Rect< int > *arg2 = 0 ;
46820   Dali::Rect< int > *result = 0 ;
46821
46822   arg1 = (Dali::Rect< int > *)jarg1;
46823   arg2 = (Dali::Rect< int > *)jarg2;
46824   if (!arg2) {
46825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46826     return 0;
46827   }
46828   {
46829     try {
46830       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
46831     } catch (std::out_of_range& e) {
46832       {
46833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46834       };
46835     } catch (std::exception& e) {
46836       {
46837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46838       };
46839     } catch (Dali::DaliException e) {
46840       {
46841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46842       };
46843     } catch (...) {
46844       {
46845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46846       };
46847     }
46848   }
46849
46850   jresult = (void *)result;
46851   return jresult;
46852 }
46853
46854
46855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
46856   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46857   int arg2 ;
46858   int arg3 ;
46859   int arg4 ;
46860   int arg5 ;
46861
46862   arg1 = (Dali::Rect< int > *)jarg1;
46863   arg2 = (int)jarg2;
46864   arg3 = (int)jarg3;
46865   arg4 = (int)jarg4;
46866   arg5 = (int)jarg5;
46867   {
46868     try {
46869       (arg1)->Set(arg2,arg3,arg4,arg5);
46870     } catch (std::out_of_range& e) {
46871       {
46872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46873       };
46874     } catch (std::exception& e) {
46875       {
46876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46877       };
46878     } catch (Dali::DaliException e) {
46879       {
46880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46881       };
46882     } catch (...) {
46883       {
46884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46885       };
46886     }
46887   }
46888
46889 }
46890
46891
46892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
46893   unsigned int jresult ;
46894   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46895   bool result;
46896
46897   arg1 = (Dali::Rect< int > *)jarg1;
46898   {
46899     try {
46900       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
46901     } catch (std::out_of_range& e) {
46902       {
46903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46904       };
46905     } catch (std::exception& e) {
46906       {
46907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46908       };
46909     } catch (Dali::DaliException e) {
46910       {
46911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46912       };
46913     } catch (...) {
46914       {
46915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46916       };
46917     }
46918   }
46919
46920   jresult = result;
46921   return jresult;
46922 }
46923
46924
46925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
46926   int jresult ;
46927   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46928   int result;
46929
46930   arg1 = (Dali::Rect< int > *)jarg1;
46931   {
46932     try {
46933       result = (int)((Dali::Rect< int > const *)arg1)->Left();
46934     } catch (std::out_of_range& e) {
46935       {
46936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46937       };
46938     } catch (std::exception& e) {
46939       {
46940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46941       };
46942     } catch (Dali::DaliException e) {
46943       {
46944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46945       };
46946     } catch (...) {
46947       {
46948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46949       };
46950     }
46951   }
46952
46953   jresult = result;
46954   return jresult;
46955 }
46956
46957
46958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
46959   int jresult ;
46960   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46961   int result;
46962
46963   arg1 = (Dali::Rect< int > *)jarg1;
46964   {
46965     try {
46966       result = (int)((Dali::Rect< int > const *)arg1)->Right();
46967     } catch (std::out_of_range& e) {
46968       {
46969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46970       };
46971     } catch (std::exception& e) {
46972       {
46973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46974       };
46975     } catch (Dali::DaliException e) {
46976       {
46977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46978       };
46979     } catch (...) {
46980       {
46981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46982       };
46983     }
46984   }
46985
46986   jresult = result;
46987   return jresult;
46988 }
46989
46990
46991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
46992   int jresult ;
46993   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46994   int result;
46995
46996   arg1 = (Dali::Rect< int > *)jarg1;
46997   {
46998     try {
46999       result = (int)((Dali::Rect< int > const *)arg1)->Top();
47000     } catch (std::out_of_range& e) {
47001       {
47002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47003       };
47004     } catch (std::exception& e) {
47005       {
47006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47007       };
47008     } catch (Dali::DaliException e) {
47009       {
47010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47011       };
47012     } catch (...) {
47013       {
47014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47015       };
47016     }
47017   }
47018
47019   jresult = result;
47020   return jresult;
47021 }
47022
47023
47024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
47025   int jresult ;
47026   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47027   int result;
47028
47029   arg1 = (Dali::Rect< int > *)jarg1;
47030   {
47031     try {
47032       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
47033     } catch (std::out_of_range& e) {
47034       {
47035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47036       };
47037     } catch (std::exception& e) {
47038       {
47039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47040       };
47041     } catch (Dali::DaliException e) {
47042       {
47043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47044       };
47045     } catch (...) {
47046       {
47047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47048       };
47049     }
47050   }
47051
47052   jresult = result;
47053   return jresult;
47054 }
47055
47056
47057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
47058   int jresult ;
47059   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47060   int result;
47061
47062   arg1 = (Dali::Rect< int > *)jarg1;
47063   {
47064     try {
47065       result = (int)((Dali::Rect< int > const *)arg1)->Area();
47066     } catch (std::out_of_range& e) {
47067       {
47068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47069       };
47070     } catch (std::exception& e) {
47071       {
47072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47073       };
47074     } catch (Dali::DaliException e) {
47075       {
47076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47077       };
47078     } catch (...) {
47079       {
47080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47081       };
47082     }
47083   }
47084
47085   jresult = result;
47086   return jresult;
47087 }
47088
47089
47090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
47091   unsigned int jresult ;
47092   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47093   Dali::Rect< int > *arg2 = 0 ;
47094   bool result;
47095
47096   arg1 = (Dali::Rect< int > *)jarg1;
47097   arg2 = (Dali::Rect< int > *)jarg2;
47098   if (!arg2) {
47099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47100     return 0;
47101   }
47102   {
47103     try {
47104       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
47105     } catch (std::out_of_range& e) {
47106       {
47107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47108       };
47109     } catch (std::exception& e) {
47110       {
47111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47112       };
47113     } catch (Dali::DaliException e) {
47114       {
47115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47116       };
47117     } catch (...) {
47118       {
47119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47120       };
47121     }
47122   }
47123
47124   jresult = result;
47125   return jresult;
47126 }
47127
47128
47129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
47130   unsigned int jresult ;
47131   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47132   Dali::Rect< int > *arg2 = 0 ;
47133   bool result;
47134
47135   arg1 = (Dali::Rect< int > *)jarg1;
47136   arg2 = (Dali::Rect< int > *)jarg2;
47137   if (!arg2) {
47138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47139     return 0;
47140   }
47141   {
47142     try {
47143       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
47144     } catch (std::out_of_range& e) {
47145       {
47146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47147       };
47148     } catch (std::exception& e) {
47149       {
47150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47151       };
47152     } catch (Dali::DaliException e) {
47153       {
47154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47155       };
47156     } catch (...) {
47157       {
47158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47159       };
47160     }
47161   }
47162
47163   jresult = result;
47164   return jresult;
47165 }
47166
47167
47168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
47169   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47170   int arg2 ;
47171
47172   arg1 = (Dali::Rect< int > *)jarg1;
47173   arg2 = (int)jarg2;
47174   if (arg1) (arg1)->x = arg2;
47175 }
47176
47177
47178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
47179   int jresult ;
47180   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47181   int result;
47182
47183   arg1 = (Dali::Rect< int > *)jarg1;
47184   result = (int) ((arg1)->x);
47185   jresult = result;
47186   return jresult;
47187 }
47188
47189
47190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
47191   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47192   int arg2 ;
47193
47194   arg1 = (Dali::Rect< int > *)jarg1;
47195   arg2 = (int)jarg2;
47196   if (arg1) (arg1)->left = arg2;
47197 }
47198
47199
47200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
47201   int jresult ;
47202   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47203   int result;
47204
47205   arg1 = (Dali::Rect< int > *)jarg1;
47206   result = (int) ((arg1)->left);
47207   jresult = result;
47208   return jresult;
47209 }
47210
47211
47212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
47213   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47214   int arg2 ;
47215
47216   arg1 = (Dali::Rect< int > *)jarg1;
47217   arg2 = (int)jarg2;
47218   if (arg1) (arg1)->y = arg2;
47219 }
47220
47221
47222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
47223   int jresult ;
47224   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47225   int result;
47226
47227   arg1 = (Dali::Rect< int > *)jarg1;
47228   result = (int) ((arg1)->y);
47229   jresult = result;
47230   return jresult;
47231 }
47232
47233
47234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
47235   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47236   int arg2 ;
47237
47238   arg1 = (Dali::Rect< int > *)jarg1;
47239   arg2 = (int)jarg2;
47240   if (arg1) (arg1)->right = arg2;
47241 }
47242
47243
47244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
47245   int jresult ;
47246   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47247   int result;
47248
47249   arg1 = (Dali::Rect< int > *)jarg1;
47250   result = (int) ((arg1)->right);
47251   jresult = result;
47252   return jresult;
47253 }
47254
47255
47256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
47257   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47258   int arg2 ;
47259
47260   arg1 = (Dali::Rect< int > *)jarg1;
47261   arg2 = (int)jarg2;
47262   if (arg1) (arg1)->width = arg2;
47263 }
47264
47265
47266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
47267   int jresult ;
47268   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47269   int result;
47270
47271   arg1 = (Dali::Rect< int > *)jarg1;
47272   result = (int) ((arg1)->width);
47273   jresult = result;
47274   return jresult;
47275 }
47276
47277
47278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
47279   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47280   int arg2 ;
47281
47282   arg1 = (Dali::Rect< int > *)jarg1;
47283   arg2 = (int)jarg2;
47284   if (arg1) (arg1)->bottom = arg2;
47285 }
47286
47287
47288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
47289   int jresult ;
47290   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47291   int result;
47292
47293   arg1 = (Dali::Rect< int > *)jarg1;
47294   result = (int) ((arg1)->bottom);
47295   jresult = result;
47296   return jresult;
47297 }
47298
47299
47300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
47301   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47302   int arg2 ;
47303
47304   arg1 = (Dali::Rect< int > *)jarg1;
47305   arg2 = (int)jarg2;
47306   if (arg1) (arg1)->height = arg2;
47307 }
47308
47309
47310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
47311   int jresult ;
47312   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47313   int result;
47314
47315   arg1 = (Dali::Rect< int > *)jarg1;
47316   result = (int) ((arg1)->height);
47317   jresult = result;
47318   return jresult;
47319 }
47320
47321
47322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
47323   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47324   int arg2 ;
47325
47326   arg1 = (Dali::Rect< int > *)jarg1;
47327   arg2 = (int)jarg2;
47328   if (arg1) (arg1)->top = arg2;
47329 }
47330
47331
47332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
47333   int jresult ;
47334   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47335   int result;
47336
47337   arg1 = (Dali::Rect< int > *)jarg1;
47338   result = (int) ((arg1)->top);
47339   jresult = result;
47340   return jresult;
47341 }
47342
47343
47344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
47345   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47346
47347   arg1 = (Dali::Rect< int > *)jarg1;
47348   {
47349     try {
47350       delete arg1;
47351     } catch (std::out_of_range& e) {
47352       {
47353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47354       };
47355     } catch (std::exception& e) {
47356       {
47357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47358       };
47359     } catch (Dali::DaliException e) {
47360       {
47361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47362       };
47363     } catch (...) {
47364       {
47365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47366       };
47367     }
47368   }
47369
47370 }
47371
47372
47373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
47374   void * jresult ;
47375   Dali::Rect< float > *result = 0 ;
47376
47377   {
47378     try {
47379       result = (Dali::Rect< float > *)new Dali::Rect< float >();
47380     } catch (std::out_of_range& e) {
47381       {
47382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47383       };
47384     } catch (std::exception& e) {
47385       {
47386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47387       };
47388     } catch (Dali::DaliException e) {
47389       {
47390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47391       };
47392     } catch (...) {
47393       {
47394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47395       };
47396     }
47397   }
47398
47399   jresult = (void *)result;
47400   return jresult;
47401 }
47402
47403
47404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
47405   void * jresult ;
47406   float arg1 ;
47407   float arg2 ;
47408   float arg3 ;
47409   float arg4 ;
47410   Dali::Rect< float > *result = 0 ;
47411
47412   arg1 = (float)jarg1;
47413   arg2 = (float)jarg2;
47414   arg3 = (float)jarg4;
47415   arg4 = (float)jarg3;
47416   {
47417     try {
47418       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
47419     } catch (std::out_of_range& e) {
47420       {
47421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47422       };
47423     } catch (std::exception& e) {
47424       {
47425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47426       };
47427     } catch (Dali::DaliException e) {
47428       {
47429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47430       };
47431     } catch (...) {
47432       {
47433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47434       };
47435     }
47436   }
47437
47438   jresult = (void *)result;
47439   return jresult;
47440 }
47441
47442
47443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
47444   void * jresult ;
47445   Dali::Rect< float > *arg1 = 0 ;
47446   Dali::Rect< float > *result = 0 ;
47447
47448   arg1 = (Dali::Rect< float > *)jarg1;
47449   if (!arg1) {
47450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47451     return 0;
47452   }
47453   {
47454     try {
47455       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
47456     } catch (std::out_of_range& e) {
47457       {
47458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47459       };
47460     } catch (std::exception& e) {
47461       {
47462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47463       };
47464     } catch (Dali::DaliException e) {
47465       {
47466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47467       };
47468     } catch (...) {
47469       {
47470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47471       };
47472     }
47473   }
47474
47475   jresult = (void *)result;
47476   return jresult;
47477 }
47478
47479
47480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
47481   void * jresult ;
47482   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47483   Dali::Rect< float > *arg2 = 0 ;
47484   Dali::Rect< float > *result = 0 ;
47485
47486   arg1 = (Dali::Rect< float > *)jarg1;
47487   arg2 = (Dali::Rect< float > *)jarg2;
47488   if (!arg2) {
47489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47490     return 0;
47491   }
47492   {
47493     try {
47494       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
47495     } catch (std::out_of_range& e) {
47496       {
47497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47498       };
47499     } catch (std::exception& e) {
47500       {
47501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47502       };
47503     } catch (Dali::DaliException e) {
47504       {
47505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47506       };
47507     } catch (...) {
47508       {
47509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47510       };
47511     }
47512   }
47513
47514   jresult = (void *)result;
47515   return jresult;
47516 }
47517
47518
47519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
47520   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47521   float arg2 ;
47522   float arg3 ;
47523   float arg4 ;
47524   float arg5 ;
47525
47526   arg1 = (Dali::Rect< float > *)jarg1;
47527   arg2 = (float)jarg2;
47528   arg3 = (float)jarg3;
47529   arg4 = (float)jarg5;
47530   arg5 = (float)jarg4;
47531   {
47532     try {
47533       (arg1)->Set(arg2,arg3,arg4,arg5);
47534     } catch (std::out_of_range& e) {
47535       {
47536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47537       };
47538     } catch (std::exception& e) {
47539       {
47540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47541       };
47542     } catch (Dali::DaliException e) {
47543       {
47544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47545       };
47546     } catch (...) {
47547       {
47548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47549       };
47550     }
47551   }
47552
47553 }
47554
47555
47556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
47557   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47558   float arg2 ;
47559
47560   arg1 = (Dali::Rect< float > *)jarg1;
47561   arg2 = (float)jarg2;
47562   if (arg1) (arg1)->left = arg2;
47563 }
47564
47565
47566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
47567   float jresult ;
47568   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47569   float result;
47570
47571   arg1 = (Dali::Rect< float > *)jarg1;
47572   result = (float) ((arg1)->left);
47573   jresult = result;
47574   return jresult;
47575 }
47576
47577
47578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
47579   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47580   float arg2 ;
47581
47582   arg1 = (Dali::Rect< float > *)jarg1;
47583   arg2 = (float)jarg2;
47584   if (arg1) (arg1)->left = arg2;
47585 }
47586
47587
47588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
47589   float jresult ;
47590   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47591   float result;
47592
47593   arg1 = (Dali::Rect< float > *)jarg1;
47594   result = (float) ((arg1)->left);
47595   jresult = result;
47596   return jresult;
47597 }
47598
47599
47600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
47601   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47602   float arg2 ;
47603
47604   arg1 = (Dali::Rect< float > *)jarg1;
47605   arg2 = (float)jarg2;
47606   if (arg1) (arg1)->right = arg2;
47607 }
47608
47609
47610 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
47611   float jresult ;
47612   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47613   float result;
47614
47615   arg1 = (Dali::Rect< float > *)jarg1;
47616   result = (float) ((arg1)->right);
47617   jresult = result;
47618   return jresult;
47619 }
47620
47621
47622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
47623   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47624   float arg2 ;
47625
47626   arg1 = (Dali::Rect< float > *)jarg1;
47627   arg2 = (float)jarg2;
47628   if (arg1) (arg1)->right = arg2;
47629 }
47630
47631
47632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
47633   float jresult ;
47634   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47635   float result;
47636
47637   arg1 = (Dali::Rect< float > *)jarg1;
47638   result = (float) ((arg1)->right);
47639   jresult = result;
47640   return jresult;
47641 }
47642
47643
47644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
47645   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47646   float arg2 ;
47647
47648   arg1 = (Dali::Rect< float > *)jarg1;
47649   arg2 = (float)jarg2;
47650   if (arg1) (arg1)->bottom = arg2;
47651 }
47652
47653
47654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
47655   float jresult ;
47656   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47657   float result;
47658
47659   arg1 = (Dali::Rect< float > *)jarg1;
47660   result = (float) ((arg1)->bottom);
47661   jresult = result;
47662   return jresult;
47663 }
47664
47665
47666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
47667   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47668   float arg2 ;
47669
47670   arg1 = (Dali::Rect< float > *)jarg1;
47671   arg2 = (float)jarg2;
47672   if (arg1) (arg1)->top = arg2;
47673 }
47674
47675
47676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
47677   float jresult ;
47678   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47679   float result;
47680
47681   arg1 = (Dali::Rect< float > *)jarg1;
47682   result = (float) ((arg1)->top);
47683   jresult = result;
47684   return jresult;
47685 }
47686
47687
47688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
47689   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47690
47691   arg1 = (Dali::Rect< float > *)jarg1;
47692   {
47693     try {
47694       delete arg1;
47695     } catch (std::out_of_range& e) {
47696       {
47697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47698       };
47699     } catch (std::exception& e) {
47700       {
47701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47702       };
47703     } catch (Dali::DaliException e) {
47704       {
47705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47706       };
47707     } catch (...) {
47708       {
47709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47710       };
47711     }
47712   }
47713
47714 }
47715
47716
47717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
47718   int jresult ;
47719   int result;
47720
47721   result = (int)Dali::Vector< int >::BaseType;
47722   jresult = (int)result;
47723   return jresult;
47724 }
47725
47726
47727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
47728   void * jresult ;
47729   Dali::Vector< int > *result = 0 ;
47730
47731   {
47732     try {
47733       result = (Dali::Vector< int > *)new Dali::Vector< int >();
47734     } catch (std::out_of_range& e) {
47735       {
47736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47737       };
47738     } catch (std::exception& e) {
47739       {
47740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47741       };
47742     } catch (Dali::DaliException e) {
47743       {
47744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47745       };
47746     } catch (...) {
47747       {
47748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47749       };
47750     }
47751   }
47752
47753   jresult = (void *)result;
47754   return jresult;
47755 }
47756
47757
47758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
47759   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47760
47761   arg1 = (Dali::Vector< int > *)jarg1;
47762   {
47763     try {
47764       delete arg1;
47765     } catch (std::out_of_range& e) {
47766       {
47767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47768       };
47769     } catch (std::exception& e) {
47770       {
47771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47772       };
47773     } catch (Dali::DaliException e) {
47774       {
47775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47776       };
47777     } catch (...) {
47778       {
47779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47780       };
47781     }
47782   }
47783
47784 }
47785
47786
47787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
47788   void * jresult ;
47789   Dali::Vector< int > *arg1 = 0 ;
47790   Dali::Vector< int > *result = 0 ;
47791
47792   arg1 = (Dali::Vector< int > *)jarg1;
47793   if (!arg1) {
47794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47795     return 0;
47796   }
47797   {
47798     try {
47799       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
47800     } catch (std::out_of_range& e) {
47801       {
47802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47803       };
47804     } catch (std::exception& e) {
47805       {
47806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47807       };
47808     } catch (Dali::DaliException e) {
47809       {
47810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47811       };
47812     } catch (...) {
47813       {
47814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47815       };
47816     }
47817   }
47818
47819   jresult = (void *)result;
47820   return jresult;
47821 }
47822
47823
47824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
47825   void * jresult ;
47826   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47827   Dali::Vector< int > *arg2 = 0 ;
47828   Dali::Vector< int > *result = 0 ;
47829
47830   arg1 = (Dali::Vector< int > *)jarg1;
47831   arg2 = (Dali::Vector< int > *)jarg2;
47832   if (!arg2) {
47833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47834     return 0;
47835   }
47836   {
47837     try {
47838       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
47839     } catch (std::out_of_range& e) {
47840       {
47841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47842       };
47843     } catch (std::exception& e) {
47844       {
47845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47846       };
47847     } catch (Dali::DaliException e) {
47848       {
47849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47850       };
47851     } catch (...) {
47852       {
47853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47854       };
47855     }
47856   }
47857
47858   jresult = (void *)result;
47859   return jresult;
47860 }
47861
47862
47863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
47864   void * jresult ;
47865   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47866   Dali::Vector< int >::Iterator result;
47867
47868   arg1 = (Dali::Vector< int > *)jarg1;
47869   {
47870     try {
47871       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
47872     } catch (std::out_of_range& e) {
47873       {
47874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47875       };
47876     } catch (std::exception& e) {
47877       {
47878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47879       };
47880     } catch (Dali::DaliException e) {
47881       {
47882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47883       };
47884     } catch (...) {
47885       {
47886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47887       };
47888     }
47889   }
47890
47891   jresult = (void *)result;
47892   return jresult;
47893 }
47894
47895
47896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
47897   void * jresult ;
47898   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47899   Dali::Vector< int >::Iterator result;
47900
47901   arg1 = (Dali::Vector< int > *)jarg1;
47902   {
47903     try {
47904       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
47905     } catch (std::out_of_range& e) {
47906       {
47907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47908       };
47909     } catch (std::exception& e) {
47910       {
47911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47912       };
47913     } catch (Dali::DaliException e) {
47914       {
47915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47916       };
47917     } catch (...) {
47918       {
47919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47920       };
47921     }
47922   }
47923
47924   jresult = (void *)result;
47925   return jresult;
47926 }
47927
47928
47929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47930   void * jresult ;
47931   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47932   Dali::Vector< int >::SizeType arg2 ;
47933   Dali::Vector< int >::ItemType *result = 0 ;
47934
47935   arg1 = (Dali::Vector< int > *)jarg1;
47936   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47937   {
47938     try {
47939       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
47940     } catch (std::out_of_range& e) {
47941       {
47942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47943       };
47944     } catch (std::exception& e) {
47945       {
47946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47947       };
47948     } catch (Dali::DaliException e) {
47949       {
47950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47951       };
47952     } catch (...) {
47953       {
47954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47955       };
47956     }
47957   }
47958
47959   jresult = (void *)result;
47960   return jresult;
47961 }
47962
47963
47964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
47965   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47966   Dali::Vector< int >::ItemType *arg2 = 0 ;
47967   Dali::Vector< int >::ItemType temp2 ;
47968
47969   arg1 = (Dali::Vector< int > *)jarg1;
47970   temp2 = (Dali::Vector< int >::ItemType)jarg2;
47971   arg2 = &temp2;
47972   {
47973     try {
47974       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
47975     } catch (std::out_of_range& e) {
47976       {
47977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47978       };
47979     } catch (std::exception& e) {
47980       {
47981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47982       };
47983     } catch (Dali::DaliException e) {
47984       {
47985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47986       };
47987     } catch (...) {
47988       {
47989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47990       };
47991     }
47992   }
47993
47994 }
47995
47996
47997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
47998   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47999   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48000   Dali::Vector< int >::ItemType *arg3 = 0 ;
48001   Dali::Vector< int >::ItemType temp3 ;
48002
48003   arg1 = (Dali::Vector< int > *)jarg1;
48004   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48005   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48006   arg3 = &temp3;
48007   {
48008     try {
48009       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48010     } catch (std::out_of_range& e) {
48011       {
48012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48013       };
48014     } catch (std::exception& e) {
48015       {
48016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48017       };
48018     } catch (Dali::DaliException e) {
48019       {
48020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48021       };
48022     } catch (...) {
48023       {
48024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48025       };
48026     }
48027   }
48028
48029 }
48030
48031
48032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48033   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48034   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48035   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48036   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
48037
48038   arg1 = (Dali::Vector< int > *)jarg1;
48039   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48040   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48041   arg4 = (Dali::Vector< int >::Iterator)jarg4;
48042   {
48043     try {
48044       (arg1)->Insert(arg2,arg3,arg4);
48045     } catch (std::out_of_range& e) {
48046       {
48047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48048       };
48049     } catch (std::exception& e) {
48050       {
48051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48052       };
48053     } catch (Dali::DaliException e) {
48054       {
48055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48056       };
48057     } catch (...) {
48058       {
48059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48060       };
48061     }
48062   }
48063
48064 }
48065
48066
48067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
48068   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48069   Dali::Vector< int >::SizeType arg2 ;
48070
48071   arg1 = (Dali::Vector< int > *)jarg1;
48072   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48073   {
48074     try {
48075       (arg1)->Reserve(arg2);
48076     } catch (std::out_of_range& e) {
48077       {
48078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48079       };
48080     } catch (std::exception& e) {
48081       {
48082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48083       };
48084     } catch (Dali::DaliException e) {
48085       {
48086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48087       };
48088     } catch (...) {
48089       {
48090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48091       };
48092     }
48093   }
48094
48095 }
48096
48097
48098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48099   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48100   Dali::Vector< int >::SizeType arg2 ;
48101
48102   arg1 = (Dali::Vector< int > *)jarg1;
48103   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48104   {
48105     try {
48106       (arg1)->Resize(arg2);
48107     } catch (std::out_of_range& e) {
48108       {
48109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48110       };
48111     } catch (std::exception& e) {
48112       {
48113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48114       };
48115     } catch (Dali::DaliException e) {
48116       {
48117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48118       };
48119     } catch (...) {
48120       {
48121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48122       };
48123     }
48124   }
48125
48126 }
48127
48128
48129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
48130   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48131   Dali::Vector< int >::SizeType arg2 ;
48132   Dali::Vector< int >::ItemType *arg3 = 0 ;
48133   Dali::Vector< int >::ItemType temp3 ;
48134
48135   arg1 = (Dali::Vector< int > *)jarg1;
48136   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48137   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48138   arg3 = &temp3;
48139   {
48140     try {
48141       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48142     } catch (std::out_of_range& e) {
48143       {
48144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48145       };
48146     } catch (std::exception& e) {
48147       {
48148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48149       };
48150     } catch (Dali::DaliException e) {
48151       {
48152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48153       };
48154     } catch (...) {
48155       {
48156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48157       };
48158     }
48159   }
48160
48161 }
48162
48163
48164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
48165   void * jresult ;
48166   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48167   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48168   Dali::Vector< int >::Iterator result;
48169
48170   arg1 = (Dali::Vector< int > *)jarg1;
48171   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48172   {
48173     try {
48174       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
48175     } catch (std::out_of_range& e) {
48176       {
48177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48178       };
48179     } catch (std::exception& e) {
48180       {
48181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48182       };
48183     } catch (Dali::DaliException e) {
48184       {
48185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48186       };
48187     } catch (...) {
48188       {
48189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48190       };
48191     }
48192   }
48193
48194   jresult = (void *)result;
48195   return jresult;
48196 }
48197
48198
48199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48200   void * jresult ;
48201   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48202   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48203   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48204   Dali::Vector< int >::Iterator result;
48205
48206   arg1 = (Dali::Vector< int > *)jarg1;
48207   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48208   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48209   {
48210     try {
48211       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
48212     } catch (std::out_of_range& e) {
48213       {
48214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48215       };
48216     } catch (std::exception& e) {
48217       {
48218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48219       };
48220     } catch (Dali::DaliException e) {
48221       {
48222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48223       };
48224     } catch (...) {
48225       {
48226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48227       };
48228     }
48229   }
48230
48231   jresult = (void *)result;
48232   return jresult;
48233 }
48234
48235
48236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
48237   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48238   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48239
48240   arg1 = (Dali::Vector< int > *)jarg1;
48241   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48242   {
48243     try {
48244       (arg1)->Remove(arg2);
48245     } catch (std::out_of_range& e) {
48246       {
48247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48248       };
48249     } catch (std::exception& e) {
48250       {
48251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48252       };
48253     } catch (Dali::DaliException e) {
48254       {
48255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48256       };
48257     } catch (...) {
48258       {
48259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48260       };
48261     }
48262   }
48263
48264 }
48265
48266
48267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
48268   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48269   Dali::Vector< int > *arg2 = 0 ;
48270
48271   arg1 = (Dali::Vector< int > *)jarg1;
48272   arg2 = (Dali::Vector< int > *)jarg2;
48273   if (!arg2) {
48274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
48275     return ;
48276   }
48277   {
48278     try {
48279       (arg1)->Swap(*arg2);
48280     } catch (std::out_of_range& e) {
48281       {
48282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48283       };
48284     } catch (std::exception& e) {
48285       {
48286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48287       };
48288     } catch (Dali::DaliException e) {
48289       {
48290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48291       };
48292     } catch (...) {
48293       {
48294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48295       };
48296     }
48297   }
48298
48299 }
48300
48301
48302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
48303   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48304
48305   arg1 = (Dali::Vector< int > *)jarg1;
48306   {
48307     try {
48308       (arg1)->Clear();
48309     } catch (std::out_of_range& e) {
48310       {
48311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48312       };
48313     } catch (std::exception& e) {
48314       {
48315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48316       };
48317     } catch (Dali::DaliException e) {
48318       {
48319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48320       };
48321     } catch (...) {
48322       {
48323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48324       };
48325     }
48326   }
48327
48328 }
48329
48330
48331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
48332   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48333
48334   arg1 = (Dali::Vector< int > *)jarg1;
48335   {
48336     try {
48337       (arg1)->Release();
48338     } catch (std::out_of_range& e) {
48339       {
48340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48341       };
48342     } catch (std::exception& e) {
48343       {
48344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48345       };
48346     } catch (Dali::DaliException e) {
48347       {
48348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48349       };
48350     } catch (...) {
48351       {
48352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48353       };
48354     }
48355   }
48356
48357 }
48358
48359
48360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
48361   int jresult ;
48362   int result;
48363
48364   result = (int)Dali::Vector< float >::BaseType;
48365   jresult = (int)result;
48366   return jresult;
48367 }
48368
48369
48370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
48371   void * jresult ;
48372   Dali::Vector< float > *result = 0 ;
48373
48374   {
48375     try {
48376       result = (Dali::Vector< float > *)new Dali::Vector< float >();
48377     } catch (std::out_of_range& e) {
48378       {
48379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48380       };
48381     } catch (std::exception& e) {
48382       {
48383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48384       };
48385     } catch (Dali::DaliException e) {
48386       {
48387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48388       };
48389     } catch (...) {
48390       {
48391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48392       };
48393     }
48394   }
48395
48396   jresult = (void *)result;
48397   return jresult;
48398 }
48399
48400
48401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
48402   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48403
48404   arg1 = (Dali::Vector< float > *)jarg1;
48405   {
48406     try {
48407       delete arg1;
48408     } catch (std::out_of_range& e) {
48409       {
48410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48411       };
48412     } catch (std::exception& e) {
48413       {
48414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48415       };
48416     } catch (Dali::DaliException e) {
48417       {
48418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48419       };
48420     } catch (...) {
48421       {
48422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48423       };
48424     }
48425   }
48426
48427 }
48428
48429
48430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
48431   void * jresult ;
48432   Dali::Vector< float > *arg1 = 0 ;
48433   Dali::Vector< float > *result = 0 ;
48434
48435   arg1 = (Dali::Vector< float > *)jarg1;
48436   if (!arg1) {
48437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48438     return 0;
48439   }
48440   {
48441     try {
48442       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
48443     } catch (std::out_of_range& e) {
48444       {
48445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48446       };
48447     } catch (std::exception& e) {
48448       {
48449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48450       };
48451     } catch (Dali::DaliException e) {
48452       {
48453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48454       };
48455     } catch (...) {
48456       {
48457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48458       };
48459     }
48460   }
48461
48462   jresult = (void *)result;
48463   return jresult;
48464 }
48465
48466
48467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
48468   void * jresult ;
48469   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48470   Dali::Vector< float > *arg2 = 0 ;
48471   Dali::Vector< float > *result = 0 ;
48472
48473   arg1 = (Dali::Vector< float > *)jarg1;
48474   arg2 = (Dali::Vector< float > *)jarg2;
48475   if (!arg2) {
48476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48477     return 0;
48478   }
48479   {
48480     try {
48481       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
48482     } catch (std::out_of_range& e) {
48483       {
48484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48485       };
48486     } catch (std::exception& e) {
48487       {
48488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48489       };
48490     } catch (Dali::DaliException e) {
48491       {
48492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48493       };
48494     } catch (...) {
48495       {
48496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48497       };
48498     }
48499   }
48500
48501   jresult = (void *)result;
48502   return jresult;
48503 }
48504
48505
48506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
48507   void * jresult ;
48508   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48509   Dali::Vector< float >::Iterator result;
48510
48511   arg1 = (Dali::Vector< float > *)jarg1;
48512   {
48513     try {
48514       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
48515     } catch (std::out_of_range& e) {
48516       {
48517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48518       };
48519     } catch (std::exception& e) {
48520       {
48521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48522       };
48523     } catch (Dali::DaliException e) {
48524       {
48525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48526       };
48527     } catch (...) {
48528       {
48529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48530       };
48531     }
48532   }
48533
48534   jresult = (void *)result;
48535   return jresult;
48536 }
48537
48538
48539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
48540   void * jresult ;
48541   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48542   Dali::Vector< float >::Iterator result;
48543
48544   arg1 = (Dali::Vector< float > *)jarg1;
48545   {
48546     try {
48547       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
48548     } catch (std::out_of_range& e) {
48549       {
48550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48551       };
48552     } catch (std::exception& e) {
48553       {
48554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48555       };
48556     } catch (Dali::DaliException e) {
48557       {
48558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48559       };
48560     } catch (...) {
48561       {
48562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48563       };
48564     }
48565   }
48566
48567   jresult = (void *)result;
48568   return jresult;
48569 }
48570
48571
48572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48573   void * jresult ;
48574   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48575   Dali::Vector< float >::SizeType arg2 ;
48576   Dali::Vector< float >::ItemType *result = 0 ;
48577
48578   arg1 = (Dali::Vector< float > *)jarg1;
48579   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48580   {
48581     try {
48582       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
48583     } catch (std::out_of_range& e) {
48584       {
48585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48586       };
48587     } catch (std::exception& e) {
48588       {
48589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48590       };
48591     } catch (Dali::DaliException e) {
48592       {
48593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48594       };
48595     } catch (...) {
48596       {
48597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48598       };
48599     }
48600   }
48601
48602   jresult = (void *)result;
48603   return jresult;
48604 }
48605
48606
48607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
48608   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48609   Dali::Vector< float >::ItemType *arg2 = 0 ;
48610   Dali::Vector< float >::ItemType temp2 ;
48611
48612   arg1 = (Dali::Vector< float > *)jarg1;
48613   temp2 = (Dali::Vector< float >::ItemType)jarg2;
48614   arg2 = &temp2;
48615   {
48616     try {
48617       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
48618     } catch (std::out_of_range& e) {
48619       {
48620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48621       };
48622     } catch (std::exception& e) {
48623       {
48624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48625       };
48626     } catch (Dali::DaliException e) {
48627       {
48628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48629       };
48630     } catch (...) {
48631       {
48632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48633       };
48634     }
48635   }
48636
48637 }
48638
48639
48640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
48641   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48642   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48643   Dali::Vector< float >::ItemType *arg3 = 0 ;
48644   Dali::Vector< float >::ItemType temp3 ;
48645
48646   arg1 = (Dali::Vector< float > *)jarg1;
48647   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48648   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48649   arg3 = &temp3;
48650   {
48651     try {
48652       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48653     } catch (std::out_of_range& e) {
48654       {
48655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48656       };
48657     } catch (std::exception& e) {
48658       {
48659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48660       };
48661     } catch (Dali::DaliException e) {
48662       {
48663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48664       };
48665     } catch (...) {
48666       {
48667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48668       };
48669     }
48670   }
48671
48672 }
48673
48674
48675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48676   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48677   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48678   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48679   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
48680
48681   arg1 = (Dali::Vector< float > *)jarg1;
48682   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48683   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48684   arg4 = (Dali::Vector< float >::Iterator)jarg4;
48685   {
48686     try {
48687       (arg1)->Insert(arg2,arg3,arg4);
48688     } catch (std::out_of_range& e) {
48689       {
48690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48691       };
48692     } catch (std::exception& e) {
48693       {
48694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48695       };
48696     } catch (Dali::DaliException e) {
48697       {
48698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48699       };
48700     } catch (...) {
48701       {
48702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48703       };
48704     }
48705   }
48706
48707 }
48708
48709
48710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
48711   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48712   Dali::Vector< float >::SizeType arg2 ;
48713
48714   arg1 = (Dali::Vector< float > *)jarg1;
48715   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48716   {
48717     try {
48718       (arg1)->Reserve(arg2);
48719     } catch (std::out_of_range& e) {
48720       {
48721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48722       };
48723     } catch (std::exception& e) {
48724       {
48725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48726       };
48727     } catch (Dali::DaliException e) {
48728       {
48729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48730       };
48731     } catch (...) {
48732       {
48733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48734       };
48735     }
48736   }
48737
48738 }
48739
48740 //// ========================= end of part 2 =============================
48741
48742 //// ========================== start part 3 ===============================
48743
48744
48745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48746   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48747   Dali::Vector< float >::SizeType arg2 ;
48748
48749   arg1 = (Dali::Vector< float > *)jarg1;
48750   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48751   {
48752     try {
48753       (arg1)->Resize(arg2);
48754     } catch (std::out_of_range& e) {
48755       {
48756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48757       };
48758     } catch (std::exception& e) {
48759       {
48760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48761       };
48762     } catch (Dali::DaliException e) {
48763       {
48764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48765       };
48766     } catch (...) {
48767       {
48768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48769       };
48770     }
48771   }
48772
48773 }
48774
48775
48776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
48777   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48778   Dali::Vector< float >::SizeType arg2 ;
48779   Dali::Vector< float >::ItemType *arg3 = 0 ;
48780   Dali::Vector< float >::ItemType temp3 ;
48781
48782   arg1 = (Dali::Vector< float > *)jarg1;
48783   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48784   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48785   arg3 = &temp3;
48786   {
48787     try {
48788       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48789     } catch (std::out_of_range& e) {
48790       {
48791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48792       };
48793     } catch (std::exception& e) {
48794       {
48795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48796       };
48797     } catch (Dali::DaliException e) {
48798       {
48799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48800       };
48801     } catch (...) {
48802       {
48803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48804       };
48805     }
48806   }
48807
48808 }
48809
48810
48811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
48812   void * jresult ;
48813   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48814   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48815   Dali::Vector< float >::Iterator result;
48816
48817   arg1 = (Dali::Vector< float > *)jarg1;
48818   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48819   {
48820     try {
48821       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
48822     } catch (std::out_of_range& e) {
48823       {
48824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48825       };
48826     } catch (std::exception& e) {
48827       {
48828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48829       };
48830     } catch (Dali::DaliException e) {
48831       {
48832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48833       };
48834     } catch (...) {
48835       {
48836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48837       };
48838     }
48839   }
48840
48841   jresult = (void *)result;
48842   return jresult;
48843 }
48844
48845
48846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48847   void * jresult ;
48848   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48849   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48850   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48851   Dali::Vector< float >::Iterator result;
48852
48853   arg1 = (Dali::Vector< float > *)jarg1;
48854   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48855   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48856   {
48857     try {
48858       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
48859     } catch (std::out_of_range& e) {
48860       {
48861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48862       };
48863     } catch (std::exception& e) {
48864       {
48865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48866       };
48867     } catch (Dali::DaliException e) {
48868       {
48869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48870       };
48871     } catch (...) {
48872       {
48873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48874       };
48875     }
48876   }
48877
48878   jresult = (void *)result;
48879   return jresult;
48880 }
48881
48882
48883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
48884   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48885   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48886
48887   arg1 = (Dali::Vector< float > *)jarg1;
48888   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48889   {
48890     try {
48891       (arg1)->Remove(arg2);
48892     } catch (std::out_of_range& e) {
48893       {
48894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48895       };
48896     } catch (std::exception& e) {
48897       {
48898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48899       };
48900     } catch (Dali::DaliException e) {
48901       {
48902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48903       };
48904     } catch (...) {
48905       {
48906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48907       };
48908     }
48909   }
48910
48911 }
48912
48913
48914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
48915   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48916   Dali::Vector< float > *arg2 = 0 ;
48917
48918   arg1 = (Dali::Vector< float > *)jarg1;
48919   arg2 = (Dali::Vector< float > *)jarg2;
48920   if (!arg2) {
48921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
48922     return ;
48923   }
48924   {
48925     try {
48926       (arg1)->Swap(*arg2);
48927     } catch (std::out_of_range& e) {
48928       {
48929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48930       };
48931     } catch (std::exception& e) {
48932       {
48933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48934       };
48935     } catch (Dali::DaliException e) {
48936       {
48937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48938       };
48939     } catch (...) {
48940       {
48941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48942       };
48943     }
48944   }
48945
48946 }
48947
48948
48949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
48950   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48951
48952   arg1 = (Dali::Vector< float > *)jarg1;
48953   {
48954     try {
48955       (arg1)->Clear();
48956     } catch (std::out_of_range& e) {
48957       {
48958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48959       };
48960     } catch (std::exception& e) {
48961       {
48962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48963       };
48964     } catch (Dali::DaliException e) {
48965       {
48966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48967       };
48968     } catch (...) {
48969       {
48970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48971       };
48972     }
48973   }
48974
48975 }
48976
48977
48978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
48979   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48980
48981   arg1 = (Dali::Vector< float > *)jarg1;
48982   {
48983     try {
48984       (arg1)->Release();
48985     } catch (std::out_of_range& e) {
48986       {
48987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48988       };
48989     } catch (std::exception& e) {
48990       {
48991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48992       };
48993     } catch (Dali::DaliException e) {
48994       {
48995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48996       };
48997     } catch (...) {
48998       {
48999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49000       };
49001     }
49002   }
49003
49004 }
49005
49006
49007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
49008   int jresult ;
49009   int result;
49010
49011   result = (int)Dali::Vector< unsigned char >::BaseType;
49012   jresult = (int)result;
49013   return jresult;
49014 }
49015
49016
49017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
49018   void * jresult ;
49019   Dali::Vector< unsigned char > *result = 0 ;
49020
49021   {
49022     try {
49023       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
49024     } catch (std::out_of_range& e) {
49025       {
49026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49027       };
49028     } catch (std::exception& e) {
49029       {
49030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49031       };
49032     } catch (Dali::DaliException e) {
49033       {
49034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49035       };
49036     } catch (...) {
49037       {
49038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49039       };
49040     }
49041   }
49042
49043   jresult = (void *)result;
49044   return jresult;
49045 }
49046
49047
49048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
49049   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49050
49051   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49052   {
49053     try {
49054       delete arg1;
49055     } catch (std::out_of_range& e) {
49056       {
49057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49058       };
49059     } catch (std::exception& e) {
49060       {
49061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49062       };
49063     } catch (Dali::DaliException e) {
49064       {
49065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49066       };
49067     } catch (...) {
49068       {
49069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49070       };
49071     }
49072   }
49073
49074 }
49075
49076
49077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
49078   void * jresult ;
49079   Dali::Vector< unsigned char > *arg1 = 0 ;
49080   Dali::Vector< unsigned char > *result = 0 ;
49081
49082   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49083   if (!arg1) {
49084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49085     return 0;
49086   }
49087   {
49088     try {
49089       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
49090     } catch (std::out_of_range& e) {
49091       {
49092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49093       };
49094     } catch (std::exception& e) {
49095       {
49096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49097       };
49098     } catch (Dali::DaliException e) {
49099       {
49100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49101       };
49102     } catch (...) {
49103       {
49104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49105       };
49106     }
49107   }
49108
49109   jresult = (void *)result;
49110   return jresult;
49111 }
49112
49113
49114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
49115   void * jresult ;
49116   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49117   Dali::Vector< unsigned char > *arg2 = 0 ;
49118   Dali::Vector< unsigned char > *result = 0 ;
49119
49120   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49121   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49122   if (!arg2) {
49123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49124     return 0;
49125   }
49126   {
49127     try {
49128       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
49129     } catch (std::out_of_range& e) {
49130       {
49131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49132       };
49133     } catch (std::exception& e) {
49134       {
49135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49136       };
49137     } catch (Dali::DaliException e) {
49138       {
49139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49140       };
49141     } catch (...) {
49142       {
49143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49144       };
49145     }
49146   }
49147
49148   jresult = (void *)result;
49149   return jresult;
49150 }
49151
49152
49153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
49154   void * jresult ;
49155   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49156   Dali::Vector< unsigned char >::Iterator result;
49157
49158   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49159   {
49160     try {
49161       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
49162     } catch (std::out_of_range& e) {
49163       {
49164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49165       };
49166     } catch (std::exception& e) {
49167       {
49168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49169       };
49170     } catch (Dali::DaliException e) {
49171       {
49172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49173       };
49174     } catch (...) {
49175       {
49176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49177       };
49178     }
49179   }
49180
49181   jresult = (void *)result;
49182   return jresult;
49183 }
49184
49185
49186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
49187   void * jresult ;
49188   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49189   Dali::Vector< unsigned char >::Iterator result;
49190
49191   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49192   {
49193     try {
49194       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
49195     } catch (std::out_of_range& e) {
49196       {
49197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49198       };
49199     } catch (std::exception& e) {
49200       {
49201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49202       };
49203     } catch (Dali::DaliException e) {
49204       {
49205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49206       };
49207     } catch (...) {
49208       {
49209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49210       };
49211     }
49212   }
49213
49214   jresult = (void *)result;
49215   return jresult;
49216 }
49217
49218
49219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49220   void * jresult ;
49221   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49222   Dali::Vector< unsigned char >::SizeType arg2 ;
49223   Dali::Vector< unsigned char >::ItemType *result = 0 ;
49224
49225   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49226   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49227   {
49228     try {
49229       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
49230     } catch (std::out_of_range& e) {
49231       {
49232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49233       };
49234     } catch (std::exception& e) {
49235       {
49236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49237       };
49238     } catch (Dali::DaliException e) {
49239       {
49240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49241       };
49242     } catch (...) {
49243       {
49244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49245       };
49246     }
49247   }
49248
49249   jresult = (void *)result;
49250   return jresult;
49251 }
49252
49253
49254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
49255   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49256   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
49257   Dali::Vector< unsigned char >::ItemType temp2 ;
49258
49259   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49260   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
49261   arg2 = &temp2;
49262   {
49263     try {
49264       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
49265     } catch (std::out_of_range& e) {
49266       {
49267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49268       };
49269     } catch (std::exception& e) {
49270       {
49271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49272       };
49273     } catch (Dali::DaliException e) {
49274       {
49275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49276       };
49277     } catch (...) {
49278       {
49279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49280       };
49281     }
49282   }
49283
49284 }
49285
49286
49287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
49288   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49289   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49290   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49291   Dali::Vector< unsigned char >::ItemType temp3 ;
49292
49293   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49294   arg2 = jarg2;
49295   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49296   arg3 = &temp3;
49297   {
49298     try {
49299       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49300     } catch (std::out_of_range& e) {
49301       {
49302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49303       };
49304     } catch (std::exception& e) {
49305       {
49306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49307       };
49308     } catch (Dali::DaliException e) {
49309       {
49310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49311       };
49312     } catch (...) {
49313       {
49314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49315       };
49316     }
49317   }
49318
49319
49320
49321 }
49322
49323
49324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
49325   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49326   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49327   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49328   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49329
49330   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49331   arg2 = jarg2;
49332   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49333   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
49334   {
49335     try {
49336       (arg1)->Insert(arg2,arg3,arg4);
49337     } catch (std::out_of_range& e) {
49338       {
49339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49340       };
49341     } catch (std::exception& e) {
49342       {
49343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49344       };
49345     } catch (Dali::DaliException e) {
49346       {
49347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49348       };
49349     } catch (...) {
49350       {
49351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49352       };
49353     }
49354   }
49355
49356
49357
49358 }
49359
49360
49361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
49362   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49363   Dali::Vector< unsigned char >::SizeType arg2 ;
49364
49365   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49366   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49367   {
49368     try {
49369       (arg1)->Reserve(arg2);
49370     } catch (std::out_of_range& e) {
49371       {
49372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49373       };
49374     } catch (std::exception& e) {
49375       {
49376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49377       };
49378     } catch (Dali::DaliException e) {
49379       {
49380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49381       };
49382     } catch (...) {
49383       {
49384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49385       };
49386     }
49387   }
49388
49389 }
49390
49391
49392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49393   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49394   Dali::Vector< unsigned char >::SizeType arg2 ;
49395
49396   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49397   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49398   {
49399     try {
49400       (arg1)->Resize(arg2);
49401     } catch (std::out_of_range& e) {
49402       {
49403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49404       };
49405     } catch (std::exception& e) {
49406       {
49407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49408       };
49409     } catch (Dali::DaliException e) {
49410       {
49411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49412       };
49413     } catch (...) {
49414       {
49415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49416       };
49417     }
49418   }
49419
49420 }
49421
49422
49423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
49424   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49425   Dali::Vector< unsigned char >::SizeType arg2 ;
49426   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49427   Dali::Vector< unsigned char >::ItemType temp3 ;
49428
49429   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49430   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49431   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49432   arg3 = &temp3;
49433   {
49434     try {
49435       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49436     } catch (std::out_of_range& e) {
49437       {
49438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49439       };
49440     } catch (std::exception& e) {
49441       {
49442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49443       };
49444     } catch (Dali::DaliException e) {
49445       {
49446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49447       };
49448     } catch (...) {
49449       {
49450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49451       };
49452     }
49453   }
49454
49455 }
49456
49457
49458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
49459   void * jresult ;
49460   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49461   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49462   Dali::Vector< unsigned char >::Iterator result;
49463
49464   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49465   arg2 = jarg2;
49466   {
49467     try {
49468       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
49469     } catch (std::out_of_range& e) {
49470       {
49471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49472       };
49473     } catch (std::exception& e) {
49474       {
49475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49476       };
49477     } catch (Dali::DaliException e) {
49478       {
49479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49480       };
49481     } catch (...) {
49482       {
49483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49484       };
49485     }
49486   }
49487
49488   jresult = (void *)result;
49489
49490
49491   return jresult;
49492 }
49493
49494
49495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
49496   void * jresult ;
49497   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49498   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49499   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49500   Dali::Vector< unsigned char >::Iterator result;
49501
49502   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49503   arg2 = jarg2;
49504   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49505   {
49506     try {
49507       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
49508     } catch (std::out_of_range& e) {
49509       {
49510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49511       };
49512     } catch (std::exception& e) {
49513       {
49514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49515       };
49516     } catch (Dali::DaliException e) {
49517       {
49518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49519       };
49520     } catch (...) {
49521       {
49522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49523       };
49524     }
49525   }
49526
49527   jresult = (void *)result;
49528
49529
49530   return jresult;
49531 }
49532
49533
49534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
49535   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49536   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49537
49538   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49539   arg2 = jarg2;
49540   {
49541     try {
49542       (arg1)->Remove(arg2);
49543     } catch (std::out_of_range& e) {
49544       {
49545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49546       };
49547     } catch (std::exception& e) {
49548       {
49549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49550       };
49551     } catch (Dali::DaliException e) {
49552       {
49553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49554       };
49555     } catch (...) {
49556       {
49557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49558       };
49559     }
49560   }
49561
49562
49563
49564 }
49565
49566
49567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
49568   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49569   Dali::Vector< unsigned char > *arg2 = 0 ;
49570
49571   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49572   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49573   if (!arg2) {
49574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
49575     return ;
49576   }
49577   {
49578     try {
49579       (arg1)->Swap(*arg2);
49580     } catch (std::out_of_range& e) {
49581       {
49582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49583       };
49584     } catch (std::exception& e) {
49585       {
49586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49587       };
49588     } catch (Dali::DaliException e) {
49589       {
49590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49591       };
49592     } catch (...) {
49593       {
49594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49595       };
49596     }
49597   }
49598
49599 }
49600
49601
49602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
49603   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49604
49605   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49606   {
49607     try {
49608       (arg1)->Clear();
49609     } catch (std::out_of_range& e) {
49610       {
49611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49612       };
49613     } catch (std::exception& e) {
49614       {
49615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49616       };
49617     } catch (Dali::DaliException e) {
49618       {
49619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49620       };
49621     } catch (...) {
49622       {
49623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49624       };
49625     }
49626   }
49627
49628 }
49629
49630
49631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
49632   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49633
49634   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49635   {
49636     try {
49637       (arg1)->Release();
49638     } catch (std::out_of_range& e) {
49639       {
49640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49641       };
49642     } catch (std::exception& e) {
49643       {
49644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49645       };
49646     } catch (Dali::DaliException e) {
49647       {
49648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49649       };
49650     } catch (...) {
49651       {
49652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49653       };
49654     }
49655   }
49656
49657 }
49658
49659
49660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
49661   int jresult ;
49662   int result;
49663
49664   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
49665   jresult = (int)result;
49666   return jresult;
49667 }
49668
49669
49670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
49671   void * jresult ;
49672   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49673
49674   {
49675     try {
49676       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
49677     } catch (std::out_of_range& e) {
49678       {
49679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49680       };
49681     } catch (std::exception& e) {
49682       {
49683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49684       };
49685     } catch (Dali::DaliException e) {
49686       {
49687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49688       };
49689     } catch (...) {
49690       {
49691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49692       };
49693     }
49694   }
49695
49696   jresult = (void *)result;
49697   return jresult;
49698 }
49699
49700
49701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
49702   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49703
49704   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49705   {
49706     try {
49707       delete arg1;
49708     } catch (std::out_of_range& e) {
49709       {
49710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49711       };
49712     } catch (std::exception& e) {
49713       {
49714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49715       };
49716     } catch (Dali::DaliException e) {
49717       {
49718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49719       };
49720     } catch (...) {
49721       {
49722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49723       };
49724     }
49725   }
49726
49727 }
49728
49729
49730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
49731   void * jresult ;
49732   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
49733   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49734
49735   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49736   if (!arg1) {
49737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49738     return 0;
49739   }
49740   {
49741     try {
49742       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
49743     } catch (std::out_of_range& e) {
49744       {
49745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49746       };
49747     } catch (std::exception& e) {
49748       {
49749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49750       };
49751     } catch (Dali::DaliException e) {
49752       {
49753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49754       };
49755     } catch (...) {
49756       {
49757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49758       };
49759     }
49760   }
49761
49762   jresult = (void *)result;
49763   return jresult;
49764 }
49765
49766
49767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
49768   void * jresult ;
49769   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49770   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
49771   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49772
49773   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49774   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
49775   if (!arg2) {
49776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49777     return 0;
49778   }
49779   {
49780     try {
49781       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
49782     } catch (std::out_of_range& e) {
49783       {
49784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49785       };
49786     } catch (std::exception& e) {
49787       {
49788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49789       };
49790     } catch (Dali::DaliException e) {
49791       {
49792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49793       };
49794     } catch (...) {
49795       {
49796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49797       };
49798     }
49799   }
49800
49801   jresult = (void *)result;
49802   return jresult;
49803 }
49804
49805
49806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
49807   void * jresult ;
49808   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49809   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49810
49811   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49812   {
49813     try {
49814       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
49815     } catch (std::out_of_range& e) {
49816       {
49817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49818       };
49819     } catch (std::exception& e) {
49820       {
49821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49822       };
49823     } catch (Dali::DaliException e) {
49824       {
49825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49826       };
49827     } catch (...) {
49828       {
49829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49830       };
49831     }
49832   }
49833
49834   jresult = (void *)result;
49835   return jresult;
49836 }
49837
49838
49839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
49840   void * jresult ;
49841   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49842   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49843
49844   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49845   {
49846     try {
49847       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
49848     } catch (std::out_of_range& e) {
49849       {
49850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49851       };
49852     } catch (std::exception& e) {
49853       {
49854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49855       };
49856     } catch (Dali::DaliException e) {
49857       {
49858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49859       };
49860     } catch (...) {
49861       {
49862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49863       };
49864     }
49865   }
49866
49867   jresult = (void *)result;
49868   return jresult;
49869 }
49870
49871
49872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49873   void * jresult ;
49874   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49875   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49876   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
49877
49878   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49879   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49880   {
49881     try {
49882       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
49883     } catch (std::out_of_range& e) {
49884       {
49885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49886       };
49887     } catch (std::exception& e) {
49888       {
49889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49890       };
49891     } catch (Dali::DaliException e) {
49892       {
49893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49894       };
49895     } catch (...) {
49896       {
49897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49898       };
49899     }
49900   }
49901
49902   jresult = (void *)result;
49903   return jresult;
49904 }
49905
49906
49907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
49908   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49909   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
49910
49911   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49912   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
49913   if (!arg2) {
49914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49915     return ;
49916   }
49917   {
49918     try {
49919       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
49920     } catch (std::out_of_range& e) {
49921       {
49922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49923       };
49924     } catch (std::exception& e) {
49925       {
49926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49927       };
49928     } catch (Dali::DaliException e) {
49929       {
49930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49931       };
49932     } catch (...) {
49933       {
49934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49935       };
49936     }
49937   }
49938
49939 }
49940
49941
49942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
49943   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49944   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49945   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
49946
49947   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49948   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49949   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
49950   if (!arg3) {
49951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49952     return ;
49953   }
49954   {
49955     try {
49956       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
49957     } catch (std::out_of_range& e) {
49958       {
49959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49960       };
49961     } catch (std::exception& e) {
49962       {
49963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49964       };
49965     } catch (Dali::DaliException e) {
49966       {
49967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49968       };
49969     } catch (...) {
49970       {
49971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49972       };
49973     }
49974   }
49975
49976 }
49977
49978
49979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
49980   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49981   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49982   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49983   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49984
49985   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49986   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49987   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
49988   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
49989   {
49990     try {
49991       (arg1)->Insert(arg2,arg3,arg4);
49992     } catch (std::out_of_range& e) {
49993       {
49994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49995       };
49996     } catch (std::exception& e) {
49997       {
49998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49999       };
50000     } catch (Dali::DaliException e) {
50001       {
50002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50003       };
50004     } catch (...) {
50005       {
50006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50007       };
50008     }
50009   }
50010
50011 }
50012
50013
50014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
50015   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50016   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50017
50018   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50019   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50020   {
50021     try {
50022       (arg1)->Reserve(arg2);
50023     } catch (std::out_of_range& e) {
50024       {
50025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50026       };
50027     } catch (std::exception& e) {
50028       {
50029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50030       };
50031     } catch (Dali::DaliException e) {
50032       {
50033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50034       };
50035     } catch (...) {
50036       {
50037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50038       };
50039     }
50040   }
50041
50042 }
50043
50044
50045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
50046   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50047   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50048
50049   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50050   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50051   {
50052     try {
50053       (arg1)->Resize(arg2);
50054     } catch (std::out_of_range& e) {
50055       {
50056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50057       };
50058     } catch (std::exception& e) {
50059       {
50060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50061       };
50062     } catch (Dali::DaliException e) {
50063       {
50064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50065       };
50066     } catch (...) {
50067       {
50068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50069       };
50070     }
50071   }
50072
50073 }
50074
50075
50076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
50077   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50078   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50079   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
50080
50081   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50082   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50083   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
50084   if (!arg3) {
50085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50086     return ;
50087   }
50088   {
50089     try {
50090       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
50091     } catch (std::out_of_range& e) {
50092       {
50093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50094       };
50095     } catch (std::exception& e) {
50096       {
50097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50098       };
50099     } catch (Dali::DaliException e) {
50100       {
50101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50102       };
50103     } catch (...) {
50104       {
50105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50106       };
50107     }
50108   }
50109
50110 }
50111
50112
50113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
50114   void * jresult ;
50115   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50116   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50117   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50118
50119   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50120   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50121   {
50122     try {
50123       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
50124     } catch (std::out_of_range& e) {
50125       {
50126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50127       };
50128     } catch (std::exception& e) {
50129       {
50130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50131       };
50132     } catch (Dali::DaliException e) {
50133       {
50134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50135       };
50136     } catch (...) {
50137       {
50138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50139       };
50140     }
50141   }
50142
50143   jresult = (void *)result;
50144   return jresult;
50145 }
50146
50147
50148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
50149   void * jresult ;
50150   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50151   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50152   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50153   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50154
50155   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50156   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50157   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50158   {
50159     try {
50160       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
50161     } catch (std::out_of_range& e) {
50162       {
50163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50164       };
50165     } catch (std::exception& e) {
50166       {
50167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50168       };
50169     } catch (Dali::DaliException e) {
50170       {
50171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50172       };
50173     } catch (...) {
50174       {
50175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50176       };
50177     }
50178   }
50179
50180   jresult = (void *)result;
50181   return jresult;
50182 }
50183
50184
50185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
50186   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50187   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50188
50189   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50190   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50191   {
50192     try {
50193       (arg1)->Remove(arg2);
50194     } catch (std::out_of_range& e) {
50195       {
50196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50197       };
50198     } catch (std::exception& e) {
50199       {
50200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50201       };
50202     } catch (Dali::DaliException e) {
50203       {
50204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50205       };
50206     } catch (...) {
50207       {
50208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50209       };
50210     }
50211   }
50212
50213 }
50214
50215
50216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
50217   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50218   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
50219
50220   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50221   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
50222   if (!arg2) {
50223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
50224     return ;
50225   }
50226   {
50227     try {
50228       (arg1)->Swap(*arg2);
50229     } catch (std::out_of_range& e) {
50230       {
50231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50232       };
50233     } catch (std::exception& e) {
50234       {
50235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50236       };
50237     } catch (Dali::DaliException e) {
50238       {
50239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50240       };
50241     } catch (...) {
50242       {
50243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50244       };
50245     }
50246   }
50247
50248 }
50249
50250
50251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
50252   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50253
50254   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50255   {
50256     try {
50257       (arg1)->Clear();
50258     } catch (std::out_of_range& e) {
50259       {
50260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50261       };
50262     } catch (std::exception& e) {
50263       {
50264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50265       };
50266     } catch (Dali::DaliException e) {
50267       {
50268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50269       };
50270     } catch (...) {
50271       {
50272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50273       };
50274     }
50275   }
50276
50277 }
50278
50279
50280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
50281   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50282
50283   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50284   {
50285     try {
50286       (arg1)->Release();
50287     } catch (std::out_of_range& e) {
50288       {
50289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50290       };
50291     } catch (std::exception& e) {
50292       {
50293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50294       };
50295     } catch (Dali::DaliException e) {
50296       {
50297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50298       };
50299     } catch (...) {
50300       {
50301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50302       };
50303     }
50304   }
50305
50306 }
50307
50308
50309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
50310   void * jresult ;
50311   Dali::Signal< void () > *result = 0 ;
50312
50313   {
50314     try {
50315       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
50316     } catch (std::out_of_range& e) {
50317       {
50318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50319       };
50320     } catch (std::exception& e) {
50321       {
50322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50323       };
50324     } catch (Dali::DaliException e) {
50325       {
50326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50327       };
50328     } catch (...) {
50329       {
50330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50331       };
50332     }
50333   }
50334
50335   jresult = (void *)result;
50336   return jresult;
50337 }
50338
50339
50340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
50341   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50342
50343   arg1 = (Dali::Signal< void () > *)jarg1;
50344   {
50345     try {
50346       delete arg1;
50347     } catch (std::out_of_range& e) {
50348       {
50349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50350       };
50351     } catch (std::exception& e) {
50352       {
50353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50354       };
50355     } catch (Dali::DaliException e) {
50356       {
50357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50358       };
50359     } catch (...) {
50360       {
50361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50362       };
50363     }
50364   }
50365
50366 }
50367
50368
50369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
50370   unsigned int jresult ;
50371   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50372   bool result;
50373
50374   arg1 = (Dali::Signal< void () > *)jarg1;
50375   {
50376     try {
50377       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
50378     } catch (std::out_of_range& e) {
50379       {
50380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50381       };
50382     } catch (std::exception& e) {
50383       {
50384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50385       };
50386     } catch (Dali::DaliException e) {
50387       {
50388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50389       };
50390     } catch (...) {
50391       {
50392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50393       };
50394     }
50395   }
50396
50397   jresult = result;
50398   return jresult;
50399 }
50400
50401
50402 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
50403   unsigned long jresult ;
50404   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50405   std::size_t result;
50406
50407   arg1 = (Dali::Signal< void () > *)jarg1;
50408   {
50409     try {
50410       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
50411     } catch (std::out_of_range& e) {
50412       {
50413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50414       };
50415     } catch (std::exception& e) {
50416       {
50417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50418       };
50419     } catch (Dali::DaliException e) {
50420       {
50421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50422       };
50423     } catch (...) {
50424       {
50425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50426       };
50427     }
50428   }
50429
50430   jresult = (unsigned long)result;
50431   return jresult;
50432 }
50433
50434
50435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
50436   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50437   void (*arg2)() = (void (*)()) 0 ;
50438
50439   arg1 = (Dali::Signal< void () > *)jarg1;
50440   arg2 = (void (*)())jarg2;
50441   {
50442     try {
50443       (arg1)->Connect(arg2);
50444     } catch (std::out_of_range& e) {
50445       {
50446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50447       };
50448     } catch (std::exception& e) {
50449       {
50450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50451       };
50452     } catch (Dali::DaliException e) {
50453       {
50454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50455       };
50456     } catch (...) {
50457       {
50458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50459       };
50460     }
50461   }
50462
50463 }
50464
50465
50466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
50467   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50468   void (*arg2)() = (void (*)()) 0 ;
50469
50470   arg1 = (Dali::Signal< void () > *)jarg1;
50471   arg2 = (void (*)())jarg2;
50472   {
50473     try {
50474       (arg1)->Disconnect(arg2);
50475     } catch (std::out_of_range& e) {
50476       {
50477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50478       };
50479     } catch (std::exception& e) {
50480       {
50481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50482       };
50483     } catch (Dali::DaliException e) {
50484       {
50485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50486       };
50487     } catch (...) {
50488       {
50489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50490       };
50491     }
50492   }
50493
50494 }
50495
50496
50497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
50498   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50499   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
50500   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
50501
50502   arg1 = (Dali::Signal< void () > *)jarg1;
50503   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
50504   arg3 = (Dali::FunctorDelegate *)jarg3;
50505   {
50506     try {
50507       (arg1)->Connect(arg2,arg3);
50508     } catch (std::out_of_range& e) {
50509       {
50510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50511       };
50512     } catch (std::exception& e) {
50513       {
50514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50515       };
50516     } catch (Dali::DaliException e) {
50517       {
50518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50519       };
50520     } catch (...) {
50521       {
50522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50523       };
50524     }
50525   }
50526
50527 }
50528
50529
50530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
50531   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50532
50533   arg1 = (Dali::Signal< void () > *)jarg1;
50534   {
50535     try {
50536       (arg1)->Emit();
50537     } catch (std::out_of_range& e) {
50538       {
50539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50540       };
50541     } catch (std::exception& e) {
50542       {
50543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50544       };
50545     } catch (Dali::DaliException e) {
50546       {
50547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50548       };
50549     } catch (...) {
50550       {
50551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50552       };
50553     }
50554   }
50555
50556 }
50557
50558
50559 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
50560   unsigned int jresult ;
50561   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50562   bool result;
50563
50564   arg1 = (Dali::Signal< void (float) > *)jarg1;
50565   {
50566     try {
50567       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
50568     } catch (std::out_of_range& e) {
50569       {
50570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50571       };
50572     } catch (std::exception& e) {
50573       {
50574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50575       };
50576     } catch (Dali::DaliException e) {
50577       {
50578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50579       };
50580     } catch (...) {
50581       {
50582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50583       };
50584     }
50585   }
50586
50587   jresult = result;
50588   return jresult;
50589 }
50590
50591
50592 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
50593   unsigned long jresult ;
50594   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50595   std::size_t result;
50596
50597   arg1 = (Dali::Signal< void (float) > *)jarg1;
50598   {
50599     try {
50600       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
50601     } catch (std::out_of_range& e) {
50602       {
50603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50604       };
50605     } catch (std::exception& e) {
50606       {
50607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50608       };
50609     } catch (Dali::DaliException e) {
50610       {
50611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50612       };
50613     } catch (...) {
50614       {
50615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50616       };
50617     }
50618   }
50619
50620   jresult = (unsigned long)result;
50621   return jresult;
50622 }
50623
50624
50625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
50626   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50627   void (*arg2)(float) = (void (*)(float)) 0 ;
50628
50629   arg1 = (Dali::Signal< void (float) > *)jarg1;
50630   arg2 = (void (*)(float))jarg2;
50631   {
50632     try {
50633       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
50634     } catch (std::out_of_range& e) {
50635       {
50636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50637       };
50638     } catch (std::exception& e) {
50639       {
50640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50641       };
50642     } catch (Dali::DaliException e) {
50643       {
50644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50645       };
50646     } catch (...) {
50647       {
50648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50649       };
50650     }
50651   }
50652
50653 }
50654
50655
50656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
50657   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50658   void (*arg2)(float) = (void (*)(float)) 0 ;
50659
50660   arg1 = (Dali::Signal< void (float) > *)jarg1;
50661   arg2 = (void (*)(float))jarg2;
50662   {
50663     try {
50664       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
50665     } catch (std::out_of_range& e) {
50666       {
50667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50668       };
50669     } catch (std::exception& e) {
50670       {
50671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50672       };
50673     } catch (Dali::DaliException e) {
50674       {
50675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50676       };
50677     } catch (...) {
50678       {
50679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50680       };
50681     }
50682   }
50683
50684 }
50685
50686
50687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
50688   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50689   float arg2 ;
50690
50691   arg1 = (Dali::Signal< void (float) > *)jarg1;
50692   arg2 = (float)jarg2;
50693   {
50694     try {
50695       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
50696     } catch (std::out_of_range& e) {
50697       {
50698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50699       };
50700     } catch (std::exception& e) {
50701       {
50702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50703       };
50704     } catch (Dali::DaliException e) {
50705       {
50706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50707       };
50708     } catch (...) {
50709       {
50710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50711       };
50712     }
50713   }
50714
50715 }
50716
50717
50718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
50719   void * jresult ;
50720   Dali::Signal< void (float) > *result = 0 ;
50721
50722   {
50723     try {
50724       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
50725     } catch (std::out_of_range& e) {
50726       {
50727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50728       };
50729     } catch (std::exception& e) {
50730       {
50731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50732       };
50733     } catch (Dali::DaliException e) {
50734       {
50735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50736       };
50737     } catch (...) {
50738       {
50739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50740       };
50741     }
50742   }
50743
50744   jresult = (void *)result;
50745   return jresult;
50746 }
50747
50748
50749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
50750   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50751
50752   arg1 = (Dali::Signal< void (float) > *)jarg1;
50753   {
50754     try {
50755       delete arg1;
50756     } catch (std::out_of_range& e) {
50757       {
50758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50759       };
50760     } catch (std::exception& e) {
50761       {
50762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50763       };
50764     } catch (Dali::DaliException e) {
50765       {
50766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50767       };
50768     } catch (...) {
50769       {
50770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50771       };
50772     }
50773   }
50774
50775 }
50776
50777
50778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
50779   unsigned int jresult ;
50780   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50781   bool result;
50782
50783   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50784   {
50785     try {
50786       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50787     } catch (std::out_of_range& e) {
50788       {
50789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50790       };
50791     } catch (std::exception& e) {
50792       {
50793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50794       };
50795     } catch (Dali::DaliException e) {
50796       {
50797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50798       };
50799     } catch (...) {
50800       {
50801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50802       };
50803     }
50804   }
50805
50806   jresult = result;
50807   return jresult;
50808 }
50809
50810
50811 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
50812   unsigned long jresult ;
50813   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50814   std::size_t result;
50815
50816   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50817   {
50818     try {
50819       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50820     } catch (std::out_of_range& e) {
50821       {
50822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50823       };
50824     } catch (std::exception& e) {
50825       {
50826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50827       };
50828     } catch (Dali::DaliException e) {
50829       {
50830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50831       };
50832     } catch (...) {
50833       {
50834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50835       };
50836     }
50837   }
50838
50839   jresult = (unsigned long)result;
50840   return jresult;
50841 }
50842
50843
50844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
50845   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50846   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50847
50848   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50849   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50850   {
50851     try {
50852       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
50853     } catch (std::out_of_range& e) {
50854       {
50855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50856       };
50857     } catch (std::exception& e) {
50858       {
50859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50860       };
50861     } catch (Dali::DaliException e) {
50862       {
50863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50864       };
50865     } catch (...) {
50866       {
50867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50868       };
50869     }
50870   }
50871
50872 }
50873
50874
50875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
50876   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50877   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50878
50879   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50880   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50881   {
50882     try {
50883       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
50884     } catch (std::out_of_range& e) {
50885       {
50886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50887       };
50888     } catch (std::exception& e) {
50889       {
50890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50891       };
50892     } catch (Dali::DaliException e) {
50893       {
50894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50895       };
50896     } catch (...) {
50897       {
50898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50899       };
50900     }
50901   }
50902
50903 }
50904
50905
50906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
50907   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50908   Dali::BaseHandle arg2 ;
50909   Dali::BaseHandle *argp2 ;
50910
50911   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50912   argp2 = (Dali::BaseHandle *)jarg2;
50913   if (!argp2) {
50914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50915     return ;
50916   }
50917   arg2 = *argp2;
50918   {
50919     try {
50920       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
50921     } catch (std::out_of_range& e) {
50922       {
50923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50924       };
50925     } catch (std::exception& e) {
50926       {
50927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50928       };
50929     } catch (Dali::DaliException e) {
50930       {
50931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50932       };
50933     } catch (...) {
50934       {
50935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50936       };
50937     }
50938   }
50939
50940 }
50941
50942
50943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
50944   void * jresult ;
50945   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
50946
50947   {
50948     try {
50949       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
50950     } catch (std::out_of_range& e) {
50951       {
50952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50953       };
50954     } catch (std::exception& e) {
50955       {
50956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50957       };
50958     } catch (Dali::DaliException e) {
50959       {
50960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50961       };
50962     } catch (...) {
50963       {
50964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50965       };
50966     }
50967   }
50968
50969   jresult = (void *)result;
50970   return jresult;
50971 }
50972
50973
50974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
50975   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50976
50977   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50978   {
50979     try {
50980       delete arg1;
50981     } catch (std::out_of_range& e) {
50982       {
50983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50984       };
50985     } catch (std::exception& e) {
50986       {
50987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50988       };
50989     } catch (Dali::DaliException e) {
50990       {
50991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50992       };
50993     } catch (...) {
50994       {
50995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50996       };
50997     }
50998   }
50999
51000 }
51001
51002
51003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
51004   unsigned int jresult ;
51005   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51006   bool result;
51007
51008   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51009   {
51010     try {
51011       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51012     } catch (std::out_of_range& e) {
51013       {
51014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51015       };
51016     } catch (std::exception& e) {
51017       {
51018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51019       };
51020     } catch (Dali::DaliException e) {
51021       {
51022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51023       };
51024     } catch (...) {
51025       {
51026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51027       };
51028     }
51029   }
51030
51031   jresult = result;
51032   return jresult;
51033 }
51034
51035
51036 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
51037   unsigned long jresult ;
51038   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51039   std::size_t result;
51040
51041   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51042   {
51043     try {
51044       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51045     } catch (std::out_of_range& e) {
51046       {
51047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51048       };
51049     } catch (std::exception& e) {
51050       {
51051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51052       };
51053     } catch (Dali::DaliException e) {
51054       {
51055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51056       };
51057     } catch (...) {
51058       {
51059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51060       };
51061     }
51062   }
51063
51064   jresult = (unsigned long)result;
51065   return jresult;
51066 }
51067
51068
51069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
51070   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51071   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51072
51073   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51074   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51075   {
51076     try {
51077       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
51078     } catch (std::out_of_range& e) {
51079       {
51080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51081       };
51082     } catch (std::exception& e) {
51083       {
51084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51085       };
51086     } catch (Dali::DaliException e) {
51087       {
51088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51089       };
51090     } catch (...) {
51091       {
51092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51093       };
51094     }
51095   }
51096
51097 }
51098
51099
51100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
51101   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51102   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51103
51104   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51105   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51106   {
51107     try {
51108       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
51109     } catch (std::out_of_range& e) {
51110       {
51111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51112       };
51113     } catch (std::exception& e) {
51114       {
51115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51116       };
51117     } catch (Dali::DaliException e) {
51118       {
51119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51120       };
51121     } catch (...) {
51122       {
51123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51124       };
51125     }
51126   }
51127
51128 }
51129
51130
51131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
51132   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51133   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
51134
51135   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51136   arg2 = (Dali::RefObject *)jarg2;
51137   {
51138     try {
51139       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
51140     } catch (std::out_of_range& e) {
51141       {
51142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51143       };
51144     } catch (std::exception& e) {
51145       {
51146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51147       };
51148     } catch (Dali::DaliException e) {
51149       {
51150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51151       };
51152     } catch (...) {
51153       {
51154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51155       };
51156     }
51157   }
51158
51159 }
51160
51161
51162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
51163   void * jresult ;
51164   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
51165
51166   {
51167     try {
51168       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
51169     } catch (std::out_of_range& e) {
51170       {
51171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51172       };
51173     } catch (std::exception& e) {
51174       {
51175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51176       };
51177     } catch (Dali::DaliException e) {
51178       {
51179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51180       };
51181     } catch (...) {
51182       {
51183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51184       };
51185     }
51186   }
51187
51188   jresult = (void *)result;
51189   return jresult;
51190 }
51191
51192
51193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
51194   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51195
51196   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51197   {
51198     try {
51199       delete arg1;
51200     } catch (std::out_of_range& e) {
51201       {
51202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51203       };
51204     } catch (std::exception& e) {
51205       {
51206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51207       };
51208     } catch (Dali::DaliException e) {
51209       {
51210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51211       };
51212     } catch (...) {
51213       {
51214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51215       };
51216     }
51217   }
51218
51219 }
51220
51221
51222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
51223   unsigned int jresult ;
51224   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51225   bool result;
51226
51227   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51228   {
51229     try {
51230       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51231     } catch (std::out_of_range& e) {
51232       {
51233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51234       };
51235     } catch (std::exception& e) {
51236       {
51237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51238       };
51239     } catch (Dali::DaliException e) {
51240       {
51241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51242       };
51243     } catch (...) {
51244       {
51245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51246       };
51247     }
51248   }
51249
51250   jresult = result;
51251   return jresult;
51252 }
51253
51254
51255 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
51256   unsigned long jresult ;
51257   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51258   std::size_t result;
51259
51260   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51261   {
51262     try {
51263       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51264     } catch (std::out_of_range& e) {
51265       {
51266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51267       };
51268     } catch (std::exception& e) {
51269       {
51270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51271       };
51272     } catch (Dali::DaliException e) {
51273       {
51274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51275       };
51276     } catch (...) {
51277       {
51278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51279       };
51280     }
51281   }
51282
51283   jresult = (unsigned long)result;
51284   return jresult;
51285 }
51286
51287
51288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
51289   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51290   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51291
51292   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51293   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51294   {
51295     try {
51296       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
51297     } catch (std::out_of_range& e) {
51298       {
51299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51300       };
51301     } catch (std::exception& e) {
51302       {
51303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51304       };
51305     } catch (Dali::DaliException e) {
51306       {
51307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51308       };
51309     } catch (...) {
51310       {
51311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51312       };
51313     }
51314   }
51315
51316 }
51317
51318
51319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
51320   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51321   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51322
51323   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51324   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51325   {
51326     try {
51327       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
51328     } catch (std::out_of_range& e) {
51329       {
51330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51331       };
51332     } catch (std::exception& e) {
51333       {
51334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51335       };
51336     } catch (Dali::DaliException e) {
51337       {
51338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51339       };
51340     } catch (...) {
51341       {
51342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51343       };
51344     }
51345   }
51346
51347 }
51348
51349
51350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
51351   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51352   Dali::PropertyNotification *arg2 = 0 ;
51353
51354   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51355   arg2 = (Dali::PropertyNotification *)jarg2;
51356   if (!arg2) {
51357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
51358     return ;
51359   }
51360   {
51361     try {
51362       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
51363     } catch (std::out_of_range& e) {
51364       {
51365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51366       };
51367     } catch (std::exception& e) {
51368       {
51369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51370       };
51371     } catch (Dali::DaliException e) {
51372       {
51373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51374       };
51375     } catch (...) {
51376       {
51377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51378       };
51379     }
51380   }
51381
51382 }
51383
51384
51385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
51386   void * jresult ;
51387   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
51388
51389   {
51390     try {
51391       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
51392     } catch (std::out_of_range& e) {
51393       {
51394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51395       };
51396     } catch (std::exception& e) {
51397       {
51398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51399       };
51400     } catch (Dali::DaliException e) {
51401       {
51402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51403       };
51404     } catch (...) {
51405       {
51406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51407       };
51408     }
51409   }
51410
51411   jresult = (void *)result;
51412   return jresult;
51413 }
51414
51415
51416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
51417   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51418
51419   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51420   {
51421     try {
51422       delete arg1;
51423     } catch (std::out_of_range& e) {
51424       {
51425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51426       };
51427     } catch (std::exception& e) {
51428       {
51429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51430       };
51431     } catch (Dali::DaliException e) {
51432       {
51433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51434       };
51435     } catch (...) {
51436       {
51437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51438       };
51439     }
51440   }
51441
51442 }
51443
51444
51445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
51446   void * jresult ;
51447   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
51448
51449   {
51450     try {
51451       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
51452     } catch (std::out_of_range& e) {
51453       {
51454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51455       };
51456     } catch (std::exception& e) {
51457       {
51458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51459       };
51460     } catch (Dali::DaliException e) {
51461       {
51462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51463       };
51464     } catch (...) {
51465       {
51466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51467       };
51468     }
51469   }
51470
51471   jresult = (void *)result;
51472   return jresult;
51473 }
51474
51475
51476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
51477   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
51478
51479   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
51480   {
51481     try {
51482       delete arg1;
51483     } catch (std::out_of_range& e) {
51484       {
51485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51486       };
51487     } catch (std::exception& e) {
51488       {
51489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51490       };
51491     } catch (Dali::DaliException e) {
51492       {
51493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51494       };
51495     } catch (...) {
51496       {
51497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51498       };
51499     }
51500   }
51501
51502 }
51503
51504
51505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
51506   unsigned int jresult ;
51507   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51508   bool result;
51509
51510   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51511   {
51512     try {
51513       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);
51514     } catch (std::out_of_range& e) {
51515       {
51516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51517       };
51518     } catch (std::exception& e) {
51519       {
51520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51521       };
51522     } catch (Dali::DaliException e) {
51523       {
51524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51525       };
51526     } catch (...) {
51527       {
51528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51529       };
51530     }
51531   }
51532
51533   jresult = result;
51534   return jresult;
51535 }
51536
51537
51538 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51539   unsigned long jresult ;
51540   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51541   std::size_t result;
51542
51543   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51544   {
51545     try {
51546       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);
51547     } catch (std::out_of_range& e) {
51548       {
51549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51550       };
51551     } catch (std::exception& e) {
51552       {
51553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51554       };
51555     } catch (Dali::DaliException e) {
51556       {
51557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51558       };
51559     } catch (...) {
51560       {
51561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51562       };
51563     }
51564   }
51565
51566   jresult = (unsigned long)result;
51567   return jresult;
51568 }
51569
51570
51571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51572   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51573   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51574
51575   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51576   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51577   {
51578     try {
51579       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51580     } catch (std::out_of_range& e) {
51581       {
51582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51583       };
51584     } catch (std::exception& e) {
51585       {
51586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51587       };
51588     } catch (Dali::DaliException e) {
51589       {
51590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51591       };
51592     } catch (...) {
51593       {
51594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51595       };
51596     }
51597   }
51598
51599 }
51600
51601
51602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51603   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51604   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51605
51606   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51607   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51608   {
51609     try {
51610       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51611     } catch (std::out_of_range& e) {
51612       {
51613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51614       };
51615     } catch (std::exception& e) {
51616       {
51617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51618       };
51619     } catch (Dali::DaliException e) {
51620       {
51621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51622       };
51623     } catch (...) {
51624       {
51625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51626       };
51627     }
51628   }
51629
51630 }
51631
51632
51633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51634   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51635   Dali::Actor arg2 ;
51636   Dali::LongPressGesture *arg3 = 0 ;
51637   Dali::Actor *argp2 ;
51638
51639   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51640   argp2 = (Dali::Actor *)jarg2;
51641   if (!argp2) {
51642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51643     return ;
51644   }
51645   arg2 = *argp2;
51646   arg3 = (Dali::LongPressGesture *)jarg3;
51647   if (!arg3) {
51648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
51649     return ;
51650   }
51651   {
51652     try {
51653       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
51654     } catch (std::out_of_range& e) {
51655       {
51656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51657       };
51658     } catch (std::exception& e) {
51659       {
51660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51661       };
51662     } catch (Dali::DaliException e) {
51663       {
51664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51665       };
51666     } catch (...) {
51667       {
51668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51669       };
51670     }
51671   }
51672
51673 }
51674
51675
51676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
51677   void * jresult ;
51678   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
51679
51680   {
51681     try {
51682       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
51683     } catch (std::out_of_range& e) {
51684       {
51685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51686       };
51687     } catch (std::exception& e) {
51688       {
51689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51690       };
51691     } catch (Dali::DaliException e) {
51692       {
51693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51694       };
51695     } catch (...) {
51696       {
51697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51698       };
51699     }
51700   }
51701
51702   jresult = (void *)result;
51703   return jresult;
51704 }
51705
51706
51707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
51708   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51709
51710   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51711   {
51712     try {
51713       delete arg1;
51714     } catch (std::out_of_range& e) {
51715       {
51716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51717       };
51718     } catch (std::exception& e) {
51719       {
51720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51721       };
51722     } catch (Dali::DaliException e) {
51723       {
51724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51725       };
51726     } catch (...) {
51727       {
51728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51729       };
51730     }
51731   }
51732
51733 }
51734
51735
51736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
51737   unsigned int jresult ;
51738   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51739   bool result;
51740
51741   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51742   {
51743     try {
51744       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);
51745     } catch (std::out_of_range& e) {
51746       {
51747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51748       };
51749     } catch (std::exception& e) {
51750       {
51751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51752       };
51753     } catch (Dali::DaliException e) {
51754       {
51755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51756       };
51757     } catch (...) {
51758       {
51759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51760       };
51761     }
51762   }
51763
51764   jresult = result;
51765   return jresult;
51766 }
51767
51768
51769 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
51770   unsigned long jresult ;
51771   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51772   std::size_t result;
51773
51774   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51775   {
51776     try {
51777       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);
51778     } catch (std::out_of_range& e) {
51779       {
51780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51781       };
51782     } catch (std::exception& e) {
51783       {
51784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51785       };
51786     } catch (Dali::DaliException e) {
51787       {
51788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51789       };
51790     } catch (...) {
51791       {
51792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51793       };
51794     }
51795   }
51796
51797   jresult = (unsigned long)result;
51798   return jresult;
51799 }
51800
51801
51802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
51803   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51804   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
51805
51806   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51807   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
51808   {
51809     try {
51810       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51811     } catch (std::out_of_range& e) {
51812       {
51813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51814       };
51815     } catch (std::exception& e) {
51816       {
51817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51818       };
51819     } catch (Dali::DaliException e) {
51820       {
51821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51822       };
51823     } catch (...) {
51824       {
51825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51826       };
51827     }
51828   }
51829
51830 }
51831
51832
51833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
51834   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51835   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
51836
51837   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51838   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
51839   {
51840     try {
51841       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51842     } catch (std::out_of_range& e) {
51843       {
51844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51845       };
51846     } catch (std::exception& e) {
51847       {
51848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51849       };
51850     } catch (Dali::DaliException e) {
51851       {
51852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51853       };
51854     } catch (...) {
51855       {
51856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51857       };
51858     }
51859   }
51860
51861 }
51862
51863
51864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51865   unsigned int jresult ;
51866   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51867   Dali::Actor arg2 ;
51868   Dali::TouchEvent *arg3 = 0 ;
51869   Dali::Actor *argp2 ;
51870   bool result;
51871
51872   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51873   argp2 = (Dali::Actor *)jarg2;
51874   if (!argp2) {
51875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51876     return 0;
51877   }
51878   arg2 = *argp2;
51879   arg3 = (Dali::TouchEvent *)jarg3;
51880   if (!arg3) {
51881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
51882     return 0;
51883   }
51884   {
51885     try {
51886       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
51887     } catch (std::out_of_range& e) {
51888       {
51889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51890       };
51891     } catch (std::exception& e) {
51892       {
51893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51894       };
51895     } catch (Dali::DaliException e) {
51896       {
51897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51898       };
51899     } catch (...) {
51900       {
51901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51902       };
51903     }
51904   }
51905
51906   jresult = result;
51907   return jresult;
51908 }
51909
51910
51911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
51912   void * jresult ;
51913   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
51914
51915   {
51916     try {
51917       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
51918     } catch (std::out_of_range& e) {
51919       {
51920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51921       };
51922     } catch (std::exception& e) {
51923       {
51924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51925       };
51926     } catch (Dali::DaliException e) {
51927       {
51928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51929       };
51930     } catch (...) {
51931       {
51932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51933       };
51934     }
51935   }
51936
51937   jresult = (void *)result;
51938   return jresult;
51939 }
51940
51941
51942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
51943   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51944
51945   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51946   {
51947     try {
51948       delete arg1;
51949     } catch (std::out_of_range& e) {
51950       {
51951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51952       };
51953     } catch (std::exception& e) {
51954       {
51955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51956       };
51957     } catch (Dali::DaliException e) {
51958       {
51959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51960       };
51961     } catch (...) {
51962       {
51963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51964       };
51965     }
51966   }
51967
51968 }
51969
51970
51971 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
51972   unsigned int jresult ;
51973   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51974   bool result;
51975
51976   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51977   {
51978     try {
51979       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);
51980     } catch (std::out_of_range& e) {
51981       {
51982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51983       };
51984     } catch (std::exception& e) {
51985       {
51986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51987       };
51988     } catch (Dali::DaliException e) {
51989       {
51990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51991       };
51992     } catch (...) {
51993       {
51994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51995       };
51996     }
51997   }
51998
51999   jresult = result;
52000   return jresult;
52001 }
52002
52003
52004 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
52005   unsigned long jresult ;
52006   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52007   std::size_t result;
52008
52009   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52010   {
52011     try {
52012       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);
52013     } catch (std::out_of_range& e) {
52014       {
52015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52016       };
52017     } catch (std::exception& e) {
52018       {
52019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52020       };
52021     } catch (Dali::DaliException e) {
52022       {
52023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52024       };
52025     } catch (...) {
52026       {
52027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52028       };
52029     }
52030   }
52031
52032   jresult = (unsigned long)result;
52033   return jresult;
52034 }
52035
52036
52037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
52038   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52039   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52040
52041   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52042   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52043   {
52044     try {
52045       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52046     } catch (std::out_of_range& e) {
52047       {
52048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52049       };
52050     } catch (std::exception& e) {
52051       {
52052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52053       };
52054     } catch (Dali::DaliException e) {
52055       {
52056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52057       };
52058     } catch (...) {
52059       {
52060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52061       };
52062     }
52063   }
52064
52065 }
52066
52067
52068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
52069   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52070   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52071
52072   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52073   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52074   {
52075     try {
52076       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52077     } catch (std::out_of_range& e) {
52078       {
52079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52080       };
52081     } catch (std::exception& e) {
52082       {
52083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52084       };
52085     } catch (Dali::DaliException e) {
52086       {
52087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52088       };
52089     } catch (...) {
52090       {
52091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52092       };
52093     }
52094   }
52095
52096 }
52097
52098
52099 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52100   unsigned int jresult ;
52101   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52102   Dali::Actor arg2 ;
52103   Dali::HoverEvent *arg3 = 0 ;
52104   Dali::Actor *argp2 ;
52105   bool result;
52106
52107   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52108   argp2 = (Dali::Actor *)jarg2;
52109   if (!argp2) {
52110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52111     return 0;
52112   }
52113   arg2 = *argp2;
52114   arg3 = (Dali::HoverEvent *)jarg3;
52115   if (!arg3) {
52116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
52117     return 0;
52118   }
52119   {
52120     try {
52121       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
52122     } catch (std::out_of_range& e) {
52123       {
52124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52125       };
52126     } catch (std::exception& e) {
52127       {
52128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52129       };
52130     } catch (Dali::DaliException e) {
52131       {
52132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52133       };
52134     } catch (...) {
52135       {
52136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52137       };
52138     }
52139   }
52140
52141   jresult = result;
52142   return jresult;
52143 }
52144
52145
52146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
52147   void * jresult ;
52148   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
52149
52150   {
52151     try {
52152       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
52153     } catch (std::out_of_range& e) {
52154       {
52155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52156       };
52157     } catch (std::exception& e) {
52158       {
52159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52160       };
52161     } catch (Dali::DaliException e) {
52162       {
52163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52164       };
52165     } catch (...) {
52166       {
52167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52168       };
52169     }
52170   }
52171
52172   jresult = (void *)result;
52173   return jresult;
52174 }
52175
52176
52177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
52178   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52179
52180   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52181   {
52182     try {
52183       delete arg1;
52184     } catch (std::out_of_range& e) {
52185       {
52186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52187       };
52188     } catch (std::exception& e) {
52189       {
52190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52191       };
52192     } catch (Dali::DaliException e) {
52193       {
52194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52195       };
52196     } catch (...) {
52197       {
52198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52199       };
52200     }
52201   }
52202
52203 }
52204
52205
52206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
52207   unsigned int jresult ;
52208   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52209   bool result;
52210
52211   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52212   {
52213     try {
52214       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);
52215     } catch (std::out_of_range& e) {
52216       {
52217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52218       };
52219     } catch (std::exception& e) {
52220       {
52221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52222       };
52223     } catch (Dali::DaliException e) {
52224       {
52225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52226       };
52227     } catch (...) {
52228       {
52229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52230       };
52231     }
52232   }
52233
52234   jresult = result;
52235   return jresult;
52236 }
52237
52238
52239 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
52240   unsigned long jresult ;
52241   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52242   std::size_t result;
52243
52244   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52245   {
52246     try {
52247       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);
52248     } catch (std::out_of_range& e) {
52249       {
52250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52251       };
52252     } catch (std::exception& e) {
52253       {
52254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52255       };
52256     } catch (Dali::DaliException e) {
52257       {
52258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52259       };
52260     } catch (...) {
52261       {
52262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52263       };
52264     }
52265   }
52266
52267   jresult = (unsigned long)result;
52268   return jresult;
52269 }
52270
52271
52272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
52273   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52274   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52275
52276   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52277   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52278   {
52279     try {
52280       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52281     } catch (std::out_of_range& e) {
52282       {
52283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52284       };
52285     } catch (std::exception& e) {
52286       {
52287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52288       };
52289     } catch (Dali::DaliException e) {
52290       {
52291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52292       };
52293     } catch (...) {
52294       {
52295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52296       };
52297     }
52298   }
52299
52300 }
52301
52302
52303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
52304   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52305   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52306
52307   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52308   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52309   {
52310     try {
52311       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52312     } catch (std::out_of_range& e) {
52313       {
52314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52315       };
52316     } catch (std::exception& e) {
52317       {
52318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52319       };
52320     } catch (Dali::DaliException e) {
52321       {
52322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52323       };
52324     } catch (...) {
52325       {
52326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52327       };
52328     }
52329   }
52330
52331 }
52332
52333
52334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52335   unsigned int jresult ;
52336   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52337   Dali::Actor arg2 ;
52338   Dali::WheelEvent *arg3 = 0 ;
52339   Dali::Actor *argp2 ;
52340   bool result;
52341
52342   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52343   argp2 = (Dali::Actor *)jarg2;
52344   if (!argp2) {
52345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52346     return 0;
52347   }
52348   arg2 = *argp2;
52349   arg3 = (Dali::WheelEvent *)jarg3;
52350   if (!arg3) {
52351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
52352     return 0;
52353   }
52354   {
52355     try {
52356       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
52357     } catch (std::out_of_range& e) {
52358       {
52359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52360       };
52361     } catch (std::exception& e) {
52362       {
52363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52364       };
52365     } catch (Dali::DaliException e) {
52366       {
52367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52368       };
52369     } catch (...) {
52370       {
52371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52372       };
52373     }
52374   }
52375
52376   jresult = result;
52377   return jresult;
52378 }
52379
52380
52381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
52382   void * jresult ;
52383   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
52384
52385   {
52386     try {
52387       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
52388     } catch (std::out_of_range& e) {
52389       {
52390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52391       };
52392     } catch (std::exception& e) {
52393       {
52394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52395       };
52396     } catch (Dali::DaliException e) {
52397       {
52398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52399       };
52400     } catch (...) {
52401       {
52402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52403       };
52404     }
52405   }
52406
52407   jresult = (void *)result;
52408   return jresult;
52409 }
52410
52411
52412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
52413   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52414
52415   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52416   {
52417     try {
52418       delete arg1;
52419     } catch (std::out_of_range& e) {
52420       {
52421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52422       };
52423     } catch (std::exception& e) {
52424       {
52425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52426       };
52427     } catch (Dali::DaliException e) {
52428       {
52429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52430       };
52431     } catch (...) {
52432       {
52433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52434       };
52435     }
52436   }
52437
52438 }
52439
52440
52441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
52442   unsigned int jresult ;
52443   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52444   bool result;
52445
52446   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52447   {
52448     try {
52449       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
52450     } catch (std::out_of_range& e) {
52451       {
52452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52453       };
52454     } catch (std::exception& e) {
52455       {
52456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52457       };
52458     } catch (Dali::DaliException e) {
52459       {
52460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52461       };
52462     } catch (...) {
52463       {
52464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52465       };
52466     }
52467   }
52468
52469   jresult = result;
52470   return jresult;
52471 }
52472
52473
52474 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
52475   unsigned long jresult ;
52476   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52477   std::size_t result;
52478
52479   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52480   {
52481     try {
52482       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
52483     } catch (std::out_of_range& e) {
52484       {
52485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52486       };
52487     } catch (std::exception& e) {
52488       {
52489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52490       };
52491     } catch (Dali::DaliException e) {
52492       {
52493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52494       };
52495     } catch (...) {
52496       {
52497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52498       };
52499     }
52500   }
52501
52502   jresult = (unsigned long)result;
52503   return jresult;
52504 }
52505
52506
52507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
52508   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52509   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52510
52511   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52512   arg2 = (void (*)(Dali::Actor))jarg2;
52513   {
52514     try {
52515       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
52516     } catch (std::out_of_range& e) {
52517       {
52518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52519       };
52520     } catch (std::exception& e) {
52521       {
52522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52523       };
52524     } catch (Dali::DaliException e) {
52525       {
52526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52527       };
52528     } catch (...) {
52529       {
52530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52531       };
52532     }
52533   }
52534
52535 }
52536
52537
52538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
52539   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52540   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52541
52542   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52543   arg2 = (void (*)(Dali::Actor))jarg2;
52544   {
52545     try {
52546       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
52547     } catch (std::out_of_range& e) {
52548       {
52549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52550       };
52551     } catch (std::exception& e) {
52552       {
52553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52554       };
52555     } catch (Dali::DaliException e) {
52556       {
52557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52558       };
52559     } catch (...) {
52560       {
52561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52562       };
52563     }
52564   }
52565
52566 }
52567
52568
52569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
52570   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52571   Dali::Actor arg2 ;
52572   Dali::Actor *argp2 ;
52573
52574   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52575   argp2 = (Dali::Actor *)jarg2;
52576   if (!argp2) {
52577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52578     return ;
52579   }
52580   arg2 = *argp2;
52581   {
52582     try {
52583       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
52584     } catch (std::out_of_range& e) {
52585       {
52586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52587       };
52588     } catch (std::exception& e) {
52589       {
52590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52591       };
52592     } catch (Dali::DaliException e) {
52593       {
52594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52595       };
52596     } catch (...) {
52597       {
52598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52599       };
52600     }
52601   }
52602
52603 }
52604
52605
52606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
52607   void * jresult ;
52608   Dali::Signal< void (Dali::Actor) > *result = 0 ;
52609
52610   {
52611     try {
52612       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
52613     } catch (std::out_of_range& e) {
52614       {
52615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52616       };
52617     } catch (std::exception& e) {
52618       {
52619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52620       };
52621     } catch (Dali::DaliException e) {
52622       {
52623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52624       };
52625     } catch (...) {
52626       {
52627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52628       };
52629     }
52630   }
52631
52632   jresult = (void *)result;
52633   return jresult;
52634 }
52635
52636
52637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
52638   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52639
52640   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52641   {
52642     try {
52643       delete arg1;
52644     } catch (std::out_of_range& e) {
52645       {
52646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52647       };
52648     } catch (std::exception& e) {
52649       {
52650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52651       };
52652     } catch (Dali::DaliException e) {
52653       {
52654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52655       };
52656     } catch (...) {
52657       {
52658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52659       };
52660     }
52661   }
52662
52663 }
52664
52665
52666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
52667   unsigned int jresult ;
52668   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52669   bool result;
52670
52671   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52672   {
52673     try {
52674       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52675     } catch (std::out_of_range& e) {
52676       {
52677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52678       };
52679     } catch (std::exception& e) {
52680       {
52681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52682       };
52683     } catch (Dali::DaliException e) {
52684       {
52685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52686       };
52687     } catch (...) {
52688       {
52689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52690       };
52691     }
52692   }
52693
52694   jresult = result;
52695   return jresult;
52696 }
52697
52698
52699 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
52700   unsigned long jresult ;
52701   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52702   std::size_t result;
52703
52704   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52705   {
52706     try {
52707       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52708     } catch (std::out_of_range& e) {
52709       {
52710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52711       };
52712     } catch (std::exception& e) {
52713       {
52714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52715       };
52716     } catch (Dali::DaliException e) {
52717       {
52718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52719       };
52720     } catch (...) {
52721       {
52722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52723       };
52724     }
52725   }
52726
52727   jresult = (unsigned long)result;
52728   return jresult;
52729 }
52730
52731
52732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
52733   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52734   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52735
52736   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52737   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52738   {
52739     try {
52740       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52741     } catch (std::out_of_range& e) {
52742       {
52743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52744       };
52745     } catch (std::exception& e) {
52746       {
52747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52748       };
52749     } catch (Dali::DaliException e) {
52750       {
52751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52752       };
52753     } catch (...) {
52754       {
52755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52756       };
52757     }
52758   }
52759
52760 }
52761
52762
52763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
52764   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52765   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52766
52767   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52768   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52769   {
52770     try {
52771       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52772     } catch (std::out_of_range& e) {
52773       {
52774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52775       };
52776     } catch (std::exception& e) {
52777       {
52778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52779       };
52780     } catch (Dali::DaliException e) {
52781       {
52782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52783       };
52784     } catch (...) {
52785       {
52786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52787       };
52788     }
52789   }
52790
52791 }
52792
52793
52794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
52795   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52796   Dali::KeyEvent *arg2 = 0 ;
52797
52798   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52799   arg2 = (Dali::KeyEvent *)jarg2;
52800   if (!arg2) {
52801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
52802     return ;
52803   }
52804   {
52805     try {
52806       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
52807     } catch (std::out_of_range& e) {
52808       {
52809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52810       };
52811     } catch (std::exception& e) {
52812       {
52813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52814       };
52815     } catch (Dali::DaliException e) {
52816       {
52817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52818       };
52819     } catch (...) {
52820       {
52821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52822       };
52823     }
52824   }
52825
52826 }
52827
52828
52829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
52830   void * jresult ;
52831   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
52832
52833   {
52834     try {
52835       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
52836     } catch (std::out_of_range& e) {
52837       {
52838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52839       };
52840     } catch (std::exception& e) {
52841       {
52842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52843       };
52844     } catch (Dali::DaliException e) {
52845       {
52846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52847       };
52848     } catch (...) {
52849       {
52850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52851       };
52852     }
52853   }
52854
52855   jresult = (void *)result;
52856   return jresult;
52857 }
52858
52859
52860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
52861   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52862
52863   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52864   {
52865     try {
52866       delete arg1;
52867     } catch (std::out_of_range& e) {
52868       {
52869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52870       };
52871     } catch (std::exception& e) {
52872       {
52873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52874       };
52875     } catch (Dali::DaliException e) {
52876       {
52877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52878       };
52879     } catch (...) {
52880       {
52881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52882       };
52883     }
52884   }
52885
52886 }
52887
52888
52889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
52890   unsigned int jresult ;
52891   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
52892   bool result;
52893
52894   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
52895   {
52896     try {
52897       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
52898     } catch (std::out_of_range& e) {
52899       {
52900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52901       };
52902     } catch (std::exception& e) {
52903       {
52904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52905       };
52906     } catch (Dali::DaliException e) {
52907       {
52908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52909       };
52910     } catch (...) {
52911       {
52912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52913       };
52914     }
52915   }
52916
52917   jresult = result;
52918   return jresult;
52919 }
52920
52921
52922 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
52923   unsigned long jresult ;
52924   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
52925   std::size_t result;
52926
52927   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
52928   {
52929     try {
52930       result = Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
52931     } catch (std::out_of_range& e) {
52932       {
52933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52934       };
52935     } catch (std::exception& e) {
52936       {
52937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52938       };
52939     } catch (Dali::DaliException e) {
52940       {
52941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52942       };
52943     } catch (...) {
52944       {
52945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52946       };
52947     }
52948   }
52949
52950   jresult = (unsigned long)result;
52951   return jresult;
52952 }
52953
52954
52955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
52956   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
52957   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
52958
52959   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
52960   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
52961   {
52962     try {
52963       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52964     } catch (std::out_of_range& e) {
52965       {
52966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52967       };
52968     } catch (std::exception& e) {
52969       {
52970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52971       };
52972     } catch (Dali::DaliException e) {
52973       {
52974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52975       };
52976     } catch (...) {
52977       {
52978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52979       };
52980     }
52981   }
52982
52983 }
52984
52985
52986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
52987   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
52988   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
52989
52990   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
52991   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
52992   {
52993     try {
52994       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52995     } catch (std::out_of_range& e) {
52996       {
52997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52998       };
52999     } catch (std::exception& e) {
53000       {
53001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53002       };
53003     } catch (Dali::DaliException e) {
53004       {
53005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53006       };
53007     } catch (...) {
53008       {
53009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53010       };
53011     }
53012   }
53013
53014 }
53015
53016
53017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
53018   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53019   Dali::TouchEvent *arg2 = 0 ;
53020
53021   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53022   arg2 = (Dali::TouchEvent *)jarg2;
53023   if (!arg2) {
53024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
53025     return ;
53026   }
53027   {
53028     try {
53029       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchEvent const &)*arg2);
53030     } catch (std::out_of_range& e) {
53031       {
53032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53033       };
53034     } catch (std::exception& e) {
53035       {
53036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53037       };
53038     } catch (Dali::DaliException e) {
53039       {
53040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53041       };
53042     } catch (...) {
53043       {
53044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53045       };
53046     }
53047   }
53048
53049 }
53050
53051
53052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
53053   void * jresult ;
53054   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
53055
53056   {
53057     try {
53058       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
53059     } catch (std::out_of_range& e) {
53060       {
53061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53062       };
53063     } catch (std::exception& e) {
53064       {
53065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53066       };
53067     } catch (Dali::DaliException e) {
53068       {
53069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53070       };
53071     } catch (...) {
53072       {
53073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53074       };
53075     }
53076   }
53077
53078   jresult = (void *)result;
53079   return jresult;
53080 }
53081
53082
53083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
53084   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53085
53086   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53087   {
53088     try {
53089       delete arg1;
53090     } catch (std::out_of_range& e) {
53091       {
53092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53093       };
53094     } catch (std::exception& e) {
53095       {
53096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53097       };
53098     } catch (Dali::DaliException e) {
53099       {
53100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53101       };
53102     } catch (...) {
53103       {
53104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53105       };
53106     }
53107   }
53108
53109 }
53110
53111
53112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
53113   unsigned int jresult ;
53114   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53115   bool result;
53116
53117   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53118   {
53119     try {
53120       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53121     } catch (std::out_of_range& e) {
53122       {
53123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53124       };
53125     } catch (std::exception& e) {
53126       {
53127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53128       };
53129     } catch (Dali::DaliException e) {
53130       {
53131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53132       };
53133     } catch (...) {
53134       {
53135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53136       };
53137     }
53138   }
53139
53140   jresult = result;
53141   return jresult;
53142 }
53143
53144
53145 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
53146   unsigned long jresult ;
53147   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53148   std::size_t result;
53149
53150   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53151   {
53152     try {
53153       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53154     } catch (std::out_of_range& e) {
53155       {
53156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53157       };
53158     } catch (std::exception& e) {
53159       {
53160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53161       };
53162     } catch (Dali::DaliException e) {
53163       {
53164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53165       };
53166     } catch (...) {
53167       {
53168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53169       };
53170     }
53171   }
53172
53173   jresult = (unsigned long)result;
53174   return jresult;
53175 }
53176
53177
53178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
53179   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53180   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53181
53182   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53183   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53184   {
53185     try {
53186       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53187     } catch (std::out_of_range& e) {
53188       {
53189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53190       };
53191     } catch (std::exception& e) {
53192       {
53193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53194       };
53195     } catch (Dali::DaliException e) {
53196       {
53197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53198       };
53199     } catch (...) {
53200       {
53201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53202       };
53203     }
53204   }
53205
53206 }
53207
53208
53209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
53210   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53211   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53212
53213   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53214   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53215   {
53216     try {
53217       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53218     } catch (std::out_of_range& e) {
53219       {
53220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53221       };
53222     } catch (std::exception& e) {
53223       {
53224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53225       };
53226     } catch (Dali::DaliException e) {
53227       {
53228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53229       };
53230     } catch (...) {
53231       {
53232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53233       };
53234     }
53235   }
53236
53237 }
53238
53239
53240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
53241   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53242   Dali::WheelEvent *arg2 = 0 ;
53243
53244   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53245   arg2 = (Dali::WheelEvent *)jarg2;
53246   if (!arg2) {
53247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
53248     return ;
53249   }
53250   {
53251     try {
53252       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
53253     } catch (std::out_of_range& e) {
53254       {
53255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53256       };
53257     } catch (std::exception& e) {
53258       {
53259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53260       };
53261     } catch (Dali::DaliException e) {
53262       {
53263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53264       };
53265     } catch (...) {
53266       {
53267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53268       };
53269     }
53270   }
53271
53272 }
53273
53274
53275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
53276   void * jresult ;
53277   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
53278
53279   {
53280     try {
53281       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
53282     } catch (std::out_of_range& e) {
53283       {
53284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53285       };
53286     } catch (std::exception& e) {
53287       {
53288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53289       };
53290     } catch (Dali::DaliException e) {
53291       {
53292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53293       };
53294     } catch (...) {
53295       {
53296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53297       };
53298     }
53299   }
53300
53301   jresult = (void *)result;
53302   return jresult;
53303 }
53304
53305
53306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
53307   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53308
53309   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53310   {
53311     try {
53312       delete arg1;
53313     } catch (std::out_of_range& e) {
53314       {
53315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53316       };
53317     } catch (std::exception& e) {
53318       {
53319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53320       };
53321     } catch (Dali::DaliException e) {
53322       {
53323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53324       };
53325     } catch (...) {
53326       {
53327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53328       };
53329     }
53330   }
53331
53332 }
53333
53334
53335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
53336   void * jresult ;
53337   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53338
53339   {
53340     try {
53341       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
53342     } catch (std::out_of_range& e) {
53343       {
53344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53345       };
53346     } catch (std::exception& e) {
53347       {
53348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53349       };
53350     } catch (Dali::DaliException e) {
53351       {
53352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53353       };
53354     } catch (...) {
53355       {
53356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53357       };
53358     }
53359   }
53360
53361   jresult = (void *)result;
53362   return jresult;
53363 }
53364
53365
53366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
53367   void * jresult ;
53368   Dali::Radian arg1 ;
53369   Dali::Radian arg2 ;
53370   Dali::Radian *argp1 ;
53371   Dali::Radian *argp2 ;
53372   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53373
53374   argp1 = (Dali::Radian *)jarg1;
53375   if (!argp1) {
53376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53377     return 0;
53378   }
53379   arg1 = *argp1;
53380   argp2 = (Dali::Radian *)jarg2;
53381   if (!argp2) {
53382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53383     return 0;
53384   }
53385   arg2 = *argp2;
53386   {
53387     try {
53388       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
53389     } catch (std::out_of_range& e) {
53390       {
53391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53392       };
53393     } catch (std::exception& e) {
53394       {
53395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53396       };
53397     } catch (Dali::DaliException e) {
53398       {
53399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53400       };
53401     } catch (...) {
53402       {
53403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53404       };
53405     }
53406   }
53407
53408   jresult = (void *)result;
53409   return jresult;
53410 }
53411
53412
53413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
53414   void * jresult ;
53415   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
53416   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53417
53418   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53419   if (!arg1) {
53420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
53421     return 0;
53422   }
53423   {
53424     try {
53425       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
53426     } catch (std::out_of_range& e) {
53427       {
53428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53429       };
53430     } catch (std::exception& e) {
53431       {
53432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53433       };
53434     } catch (Dali::DaliException e) {
53435       {
53436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53437       };
53438     } catch (...) {
53439       {
53440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53441       };
53442     }
53443   }
53444
53445   jresult = (void *)result;
53446   return jresult;
53447 }
53448
53449
53450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
53451   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53452   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53453
53454   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53455   arg2 = (Dali::Radian *)jarg2;
53456   if (arg1) (arg1)->first = *arg2;
53457 }
53458
53459
53460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
53461   void * jresult ;
53462   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53463   Dali::Radian *result = 0 ;
53464
53465   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53466   result = (Dali::Radian *)& ((arg1)->first);
53467   jresult = (void *)result;
53468   return jresult;
53469 }
53470
53471
53472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
53473   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53474   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53475
53476   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53477   arg2 = (Dali::Radian *)jarg2;
53478   if (arg1) (arg1)->second = *arg2;
53479 }
53480
53481
53482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
53483   void * jresult ;
53484   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53485   Dali::Radian *result = 0 ;
53486
53487   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53488   result = (Dali::Radian *)& ((arg1)->second);
53489   jresult = (void *)result;
53490   return jresult;
53491 }
53492
53493
53494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
53495   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53496
53497   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53498   {
53499     try {
53500       delete arg1;
53501     } catch (std::out_of_range& e) {
53502       {
53503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53504       };
53505     } catch (std::exception& e) {
53506       {
53507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53508       };
53509     } catch (Dali::DaliException e) {
53510       {
53511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53512       };
53513     } catch (...) {
53514       {
53515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53516       };
53517     }
53518   }
53519
53520 }
53521
53522
53523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
53524   unsigned int jresult ;
53525   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53526   bool result;
53527
53528   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53529   {
53530     try {
53531       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);
53532     } catch (std::out_of_range& e) {
53533       {
53534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53535       };
53536     } catch (std::exception& e) {
53537       {
53538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53539       };
53540     } catch (Dali::DaliException e) {
53541       {
53542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53543       };
53544     } catch (...) {
53545       {
53546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53547       };
53548     }
53549   }
53550
53551   jresult = result;
53552   return jresult;
53553 }
53554
53555
53556 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53557   unsigned long jresult ;
53558   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53559   std::size_t result;
53560
53561   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53562   {
53563     try {
53564       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);
53565     } catch (std::out_of_range& e) {
53566       {
53567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53568       };
53569     } catch (std::exception& e) {
53570       {
53571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53572       };
53573     } catch (Dali::DaliException e) {
53574       {
53575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53576       };
53577     } catch (...) {
53578       {
53579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53580       };
53581     }
53582   }
53583
53584   jresult = (unsigned long)result;
53585   return jresult;
53586 }
53587
53588
53589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53590   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53591   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53592
53593   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53594   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53595   {
53596     try {
53597       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53598     } catch (std::out_of_range& e) {
53599       {
53600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53601       };
53602     } catch (std::exception& e) {
53603       {
53604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53605       };
53606     } catch (Dali::DaliException e) {
53607       {
53608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53609       };
53610     } catch (...) {
53611       {
53612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53613       };
53614     }
53615   }
53616
53617 }
53618
53619
53620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53621   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53622   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53623
53624   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53625   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53626   {
53627     try {
53628       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53629     } catch (std::out_of_range& e) {
53630       {
53631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53632       };
53633     } catch (std::exception& e) {
53634       {
53635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53636       };
53637     } catch (Dali::DaliException e) {
53638       {
53639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53640       };
53641     } catch (...) {
53642       {
53643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53644       };
53645     }
53646   }
53647
53648 }
53649
53650
53651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53652   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53653   Dali::Actor arg2 ;
53654   Dali::PanGesture *arg3 = 0 ;
53655   Dali::Actor *argp2 ;
53656
53657   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53658   argp2 = (Dali::Actor *)jarg2;
53659   if (!argp2) {
53660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53661     return ;
53662   }
53663   arg2 = *argp2;
53664   arg3 = (Dali::PanGesture *)jarg3;
53665   if (!arg3) {
53666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
53667     return ;
53668   }
53669   {
53670     try {
53671       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
53672     } catch (std::out_of_range& e) {
53673       {
53674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53675       };
53676     } catch (std::exception& e) {
53677       {
53678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53679       };
53680     } catch (Dali::DaliException e) {
53681       {
53682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53683       };
53684     } catch (...) {
53685       {
53686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53687       };
53688     }
53689   }
53690
53691 }
53692
53693
53694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
53695   void * jresult ;
53696   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
53697
53698   {
53699     try {
53700       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
53701     } catch (std::out_of_range& e) {
53702       {
53703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53704       };
53705     } catch (std::exception& e) {
53706       {
53707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53708       };
53709     } catch (Dali::DaliException e) {
53710       {
53711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53712       };
53713     } catch (...) {
53714       {
53715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53716       };
53717     }
53718   }
53719
53720   jresult = (void *)result;
53721   return jresult;
53722 }
53723
53724
53725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
53726   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53727
53728   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53729   {
53730     try {
53731       delete arg1;
53732     } catch (std::out_of_range& e) {
53733       {
53734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53735       };
53736     } catch (std::exception& e) {
53737       {
53738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53739       };
53740     } catch (Dali::DaliException e) {
53741       {
53742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53743       };
53744     } catch (...) {
53745       {
53746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53747       };
53748     }
53749   }
53750
53751 }
53752
53753
53754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
53755   unsigned int jresult ;
53756   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53757   bool result;
53758
53759   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53760   {
53761     try {
53762       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);
53763     } catch (std::out_of_range& e) {
53764       {
53765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53766       };
53767     } catch (std::exception& e) {
53768       {
53769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53770       };
53771     } catch (Dali::DaliException e) {
53772       {
53773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53774       };
53775     } catch (...) {
53776       {
53777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53778       };
53779     }
53780   }
53781
53782   jresult = result;
53783   return jresult;
53784 }
53785
53786
53787 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53788   unsigned long jresult ;
53789   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53790   std::size_t result;
53791
53792   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53793   {
53794     try {
53795       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);
53796     } catch (std::out_of_range& e) {
53797       {
53798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53799       };
53800     } catch (std::exception& e) {
53801       {
53802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53803       };
53804     } catch (Dali::DaliException e) {
53805       {
53806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53807       };
53808     } catch (...) {
53809       {
53810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53811       };
53812     }
53813   }
53814
53815   jresult = (unsigned long)result;
53816   return jresult;
53817 }
53818
53819
53820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53821   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53822   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53823
53824   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53825   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53826   {
53827     try {
53828       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53829     } catch (std::out_of_range& e) {
53830       {
53831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53832       };
53833     } catch (std::exception& e) {
53834       {
53835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53836       };
53837     } catch (Dali::DaliException e) {
53838       {
53839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53840       };
53841     } catch (...) {
53842       {
53843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53844       };
53845     }
53846   }
53847
53848 }
53849
53850
53851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53852   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53853   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53854
53855   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53856   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53857   {
53858     try {
53859       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53860     } catch (std::out_of_range& e) {
53861       {
53862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53863       };
53864     } catch (std::exception& e) {
53865       {
53866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53867       };
53868     } catch (Dali::DaliException e) {
53869       {
53870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53871       };
53872     } catch (...) {
53873       {
53874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53875       };
53876     }
53877   }
53878
53879 }
53880
53881
53882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53883   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53884   Dali::Actor arg2 ;
53885   Dali::PinchGesture *arg3 = 0 ;
53886   Dali::Actor *argp2 ;
53887
53888   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53889   argp2 = (Dali::Actor *)jarg2;
53890   if (!argp2) {
53891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53892     return ;
53893   }
53894   arg2 = *argp2;
53895   arg3 = (Dali::PinchGesture *)jarg3;
53896   if (!arg3) {
53897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
53898     return ;
53899   }
53900   {
53901     try {
53902       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
53903     } catch (std::out_of_range& e) {
53904       {
53905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53906       };
53907     } catch (std::exception& e) {
53908       {
53909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53910       };
53911     } catch (Dali::DaliException e) {
53912       {
53913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53914       };
53915     } catch (...) {
53916       {
53917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53918       };
53919     }
53920   }
53921
53922 }
53923
53924
53925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
53926   void * jresult ;
53927   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
53928
53929   {
53930     try {
53931       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
53932     } catch (std::out_of_range& e) {
53933       {
53934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53935       };
53936     } catch (std::exception& e) {
53937       {
53938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53939       };
53940     } catch (Dali::DaliException e) {
53941       {
53942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53943       };
53944     } catch (...) {
53945       {
53946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53947       };
53948     }
53949   }
53950
53951   jresult = (void *)result;
53952   return jresult;
53953 }
53954
53955
53956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
53957   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53958
53959   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53960   {
53961     try {
53962       delete arg1;
53963     } catch (std::out_of_range& e) {
53964       {
53965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53966       };
53967     } catch (std::exception& e) {
53968       {
53969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53970       };
53971     } catch (Dali::DaliException e) {
53972       {
53973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53974       };
53975     } catch (...) {
53976       {
53977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53978       };
53979     }
53980   }
53981
53982 }
53983
53984
53985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
53986   unsigned int jresult ;
53987   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53988   bool result;
53989
53990   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53991   {
53992     try {
53993       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);
53994     } catch (std::out_of_range& e) {
53995       {
53996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53997       };
53998     } catch (std::exception& e) {
53999       {
54000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54001       };
54002     } catch (Dali::DaliException e) {
54003       {
54004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54005       };
54006     } catch (...) {
54007       {
54008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54009       };
54010     }
54011   }
54012
54013   jresult = result;
54014   return jresult;
54015 }
54016
54017
54018 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54019   unsigned long jresult ;
54020   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54021   std::size_t result;
54022
54023   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54024   {
54025     try {
54026       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);
54027     } catch (std::out_of_range& e) {
54028       {
54029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54030       };
54031     } catch (std::exception& e) {
54032       {
54033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54034       };
54035     } catch (Dali::DaliException e) {
54036       {
54037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54038       };
54039     } catch (...) {
54040       {
54041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54042       };
54043     }
54044   }
54045
54046   jresult = (unsigned long)result;
54047   return jresult;
54048 }
54049
54050
54051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54052   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54053   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54054
54055   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54056   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54057   {
54058     try {
54059       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54060     } catch (std::out_of_range& e) {
54061       {
54062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54063       };
54064     } catch (std::exception& e) {
54065       {
54066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54067       };
54068     } catch (Dali::DaliException e) {
54069       {
54070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54071       };
54072     } catch (...) {
54073       {
54074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54075       };
54076     }
54077   }
54078
54079 }
54080
54081
54082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54083   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54084   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54085
54086   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54087   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54088   {
54089     try {
54090       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54091     } catch (std::out_of_range& e) {
54092       {
54093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54094       };
54095     } catch (std::exception& e) {
54096       {
54097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54098       };
54099     } catch (Dali::DaliException e) {
54100       {
54101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54102       };
54103     } catch (...) {
54104       {
54105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54106       };
54107     }
54108   }
54109
54110 }
54111
54112
54113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54114   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54115   Dali::Actor arg2 ;
54116   Dali::TapGesture *arg3 = 0 ;
54117   Dali::Actor *argp2 ;
54118
54119   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54120   argp2 = (Dali::Actor *)jarg2;
54121   if (!argp2) {
54122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54123     return ;
54124   }
54125   arg2 = *argp2;
54126   arg3 = (Dali::TapGesture *)jarg3;
54127   if (!arg3) {
54128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
54129     return ;
54130   }
54131   {
54132     try {
54133       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
54134     } catch (std::out_of_range& e) {
54135       {
54136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54137       };
54138     } catch (std::exception& e) {
54139       {
54140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54141       };
54142     } catch (Dali::DaliException e) {
54143       {
54144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54145       };
54146     } catch (...) {
54147       {
54148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54149       };
54150     }
54151   }
54152
54153 }
54154
54155
54156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
54157   void * jresult ;
54158   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
54159
54160   {
54161     try {
54162       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
54163     } catch (std::out_of_range& e) {
54164       {
54165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54166       };
54167     } catch (std::exception& e) {
54168       {
54169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54170       };
54171     } catch (Dali::DaliException e) {
54172       {
54173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54174       };
54175     } catch (...) {
54176       {
54177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54178       };
54179     }
54180   }
54181
54182   jresult = (void *)result;
54183   return jresult;
54184 }
54185
54186
54187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
54188   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54189
54190   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54191   {
54192     try {
54193       delete arg1;
54194     } catch (std::out_of_range& e) {
54195       {
54196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54197       };
54198     } catch (std::exception& e) {
54199       {
54200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54201       };
54202     } catch (Dali::DaliException e) {
54203       {
54204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54205       };
54206     } catch (...) {
54207       {
54208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54209       };
54210     }
54211   }
54212
54213 }
54214
54215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
54216   unsigned int jresult ;
54217   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54218   bool result = false;
54219
54220   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54221   {
54222     try {
54223       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);
54224     } catch (std::out_of_range& e) {
54225       {
54226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54227       };
54228     } catch (std::exception& e) {
54229       {
54230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54231       };
54232     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54233   }
54234   jresult = result;
54235   return jresult;
54236 }
54237
54238 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
54239   unsigned long jresult ;
54240   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54241   std::size_t result = 0;
54242
54243   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54244   {
54245     try {
54246       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);
54247     } catch (std::out_of_range& e) {
54248       {
54249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54250       };
54251     } catch (std::exception& e) {
54252       {
54253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54254       };
54255     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54256   }
54257   jresult = (unsigned long)result;
54258   return jresult;
54259 }
54260
54261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
54262   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54263   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54264
54265   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54266   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54267   {
54268     try {
54269       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
54270     } catch (std::out_of_range& e) {
54271       {
54272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54273       };
54274     } catch (std::exception& e) {
54275       {
54276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54277       };
54278     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54279   }
54280 }
54281
54282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
54283   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54284   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54285
54286   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54287   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54288   {
54289     try {
54290       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
54291     } catch (std::out_of_range& e) {
54292       {
54293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54294       };
54295     } catch (std::exception& e) {
54296       {
54297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54298       };
54299     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54300   }
54301 }
54302
54303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
54304   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54305   Dali::Actor arg2 ;
54306   //bool arg3 ;
54307   Dali::LayoutDirection::Type arg4 ;
54308   Dali::Actor *argp2 ;
54309
54310   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54311   argp2 = (Dali::Actor *)jarg2;
54312   if (!argp2) {
54313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54314     return ;
54315   }
54316   arg2 = *argp2;
54317   //arg3 = jarg3 ? true : false;
54318   arg4 = (Dali::LayoutDirection::Type)jarg4;
54319   {
54320     try {
54321       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
54322     } catch (std::out_of_range& e) {
54323       {
54324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54325       };
54326     } catch (std::exception& e) {
54327       {
54328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54329       };
54330     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54331   }
54332 }
54333
54334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
54335   void * jresult ;
54336   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
54337
54338   {
54339     try {
54340       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
54341     } catch (std::out_of_range& e) {
54342       {
54343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54344       };
54345     } catch (std::exception& e) {
54346       {
54347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54348       };
54349     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54350   }
54351   jresult = (void *)result;
54352   return jresult;
54353 }
54354
54355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
54356   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54357
54358   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54359   {
54360     try {
54361       delete arg1;
54362     } catch (std::out_of_range& e) {
54363       {
54364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54365       };
54366     } catch (std::exception& e) {
54367       {
54368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54369       };
54370     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54371   }
54372 }
54373
54374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
54375   unsigned int jresult ;
54376   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54377   bool result;
54378
54379   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54380   {
54381     try {
54382       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);
54383     } catch (std::out_of_range& e) {
54384       {
54385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54386       };
54387     } catch (std::exception& e) {
54388       {
54389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54390       };
54391     } catch (Dali::DaliException e) {
54392       {
54393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54394       };
54395     } catch (...) {
54396       {
54397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54398       };
54399     }
54400   }
54401
54402   jresult = result;
54403   return jresult;
54404 }
54405
54406
54407 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
54408   unsigned long jresult ;
54409   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54410   std::size_t result;
54411
54412   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54413   {
54414     try {
54415       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);
54416     } catch (std::out_of_range& e) {
54417       {
54418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54419       };
54420     } catch (std::exception& e) {
54421       {
54422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54423       };
54424     } catch (Dali::DaliException e) {
54425       {
54426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54427       };
54428     } catch (...) {
54429       {
54430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54431       };
54432     }
54433   }
54434
54435   jresult = (unsigned long)result;
54436   return jresult;
54437 }
54438
54439
54440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
54441   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54442   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54443
54444   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54445   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54446   {
54447     try {
54448       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
54449     } catch (std::out_of_range& e) {
54450       {
54451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54452       };
54453     } catch (std::exception& e) {
54454       {
54455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54456       };
54457     } catch (Dali::DaliException e) {
54458       {
54459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54460       };
54461     } catch (...) {
54462       {
54463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54464       };
54465     }
54466   }
54467
54468 }
54469
54470
54471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54472   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54473   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54474
54475   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54476   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54477   {
54478     try {
54479       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
54480     } catch (std::out_of_range& e) {
54481       {
54482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54483       };
54484     } catch (std::exception& e) {
54485       {
54486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54487       };
54488     } catch (Dali::DaliException e) {
54489       {
54490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54491       };
54492     } catch (...) {
54493       {
54494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54495       };
54496     }
54497   }
54498
54499 }
54500
54501
54502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
54503   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54504   Dali::Actor arg2 ;
54505   bool arg3 ;
54506   Dali::DevelActor::VisibilityChange::Type arg4 ;
54507   Dali::Actor *argp2 ;
54508
54509   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54510   argp2 = (Dali::Actor *)jarg2;
54511   if (!argp2) {
54512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54513     return ;
54514   }
54515   arg2 = *argp2;
54516   arg3 = jarg3 ? true : false;
54517   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
54518   {
54519     try {
54520       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54521     } catch (std::out_of_range& e) {
54522       {
54523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54524       };
54525     } catch (std::exception& e) {
54526       {
54527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54528       };
54529     } catch (Dali::DaliException e) {
54530       {
54531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54532       };
54533     } catch (...) {
54534       {
54535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54536       };
54537     }
54538   }
54539
54540 }
54541
54542
54543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
54544   void * jresult ;
54545   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
54546
54547   {
54548     try {
54549       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
54550     } catch (std::out_of_range& e) {
54551       {
54552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54553       };
54554     } catch (std::exception& e) {
54555       {
54556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54557       };
54558     } catch (Dali::DaliException e) {
54559       {
54560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54561       };
54562     } catch (...) {
54563       {
54564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54565       };
54566     }
54567   }
54568
54569   jresult = (void *)result;
54570   return jresult;
54571 }
54572
54573
54574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
54575   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54576
54577   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54578   {
54579     try {
54580       delete arg1;
54581     } catch (std::out_of_range& e) {
54582       {
54583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54584       };
54585     } catch (std::exception& e) {
54586       {
54587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54588       };
54589     } catch (Dali::DaliException e) {
54590       {
54591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54592       };
54593     } catch (...) {
54594       {
54595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54596       };
54597     }
54598   }
54599
54600 }
54601
54602
54603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
54604   void * jresult ;
54605   Dali::Timer *result = 0 ;
54606
54607   {
54608     try {
54609       result = (Dali::Timer *)new Dali::Timer();
54610     } catch (std::out_of_range& e) {
54611       {
54612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54613       };
54614     } catch (std::exception& e) {
54615       {
54616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54617       };
54618     } catch (Dali::DaliException e) {
54619       {
54620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54621       };
54622     } catch (...) {
54623       {
54624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54625       };
54626     }
54627   }
54628
54629   jresult = (void *)result;
54630   return jresult;
54631 }
54632
54633
54634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
54635   void * jresult ;
54636   unsigned int arg1 ;
54637   Dali::Timer result;
54638
54639   arg1 = (unsigned int)jarg1;
54640   {
54641     try {
54642       result = Dali::Timer::New(arg1);
54643     } catch (std::out_of_range& e) {
54644       {
54645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54646       };
54647     } catch (std::exception& e) {
54648       {
54649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54650       };
54651     } catch (Dali::DaliException e) {
54652       {
54653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54654       };
54655     } catch (...) {
54656       {
54657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54658       };
54659     }
54660   }
54661
54662   jresult = new Dali::Timer((const Dali::Timer &)result);
54663   return jresult;
54664 }
54665
54666
54667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
54668   void * jresult ;
54669   Dali::Timer *arg1 = 0 ;
54670   Dali::Timer *result = 0 ;
54671
54672   arg1 = (Dali::Timer *)jarg1;
54673   if (!arg1) {
54674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54675     return 0;
54676   }
54677   {
54678     try {
54679       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
54680     } catch (std::out_of_range& e) {
54681       {
54682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54683       };
54684     } catch (std::exception& e) {
54685       {
54686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54687       };
54688     } catch (Dali::DaliException e) {
54689       {
54690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54691       };
54692     } catch (...) {
54693       {
54694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54695       };
54696     }
54697   }
54698
54699   jresult = (void *)result;
54700   return jresult;
54701 }
54702
54703
54704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
54705   void * jresult ;
54706   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54707   Dali::Timer *arg2 = 0 ;
54708   Dali::Timer *result = 0 ;
54709
54710   arg1 = (Dali::Timer *)jarg1;
54711   arg2 = (Dali::Timer *)jarg2;
54712   if (!arg2) {
54713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54714     return 0;
54715   }
54716   {
54717     try {
54718       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
54719     } catch (std::out_of_range& e) {
54720       {
54721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54722       };
54723     } catch (std::exception& e) {
54724       {
54725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54726       };
54727     } catch (Dali::DaliException e) {
54728       {
54729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54730       };
54731     } catch (...) {
54732       {
54733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54734       };
54735     }
54736   }
54737
54738   jresult = (void *)result;
54739   return jresult;
54740 }
54741
54742
54743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
54744   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54745
54746   arg1 = (Dali::Timer *)jarg1;
54747   {
54748     try {
54749       delete arg1;
54750     } catch (std::out_of_range& e) {
54751       {
54752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54753       };
54754     } catch (std::exception& e) {
54755       {
54756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54757       };
54758     } catch (Dali::DaliException e) {
54759       {
54760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54761       };
54762     } catch (...) {
54763       {
54764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54765       };
54766     }
54767   }
54768
54769 }
54770
54771
54772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
54773   void * jresult ;
54774   Dali::BaseHandle arg1 ;
54775   Dali::BaseHandle *argp1 ;
54776   Dali::Timer result;
54777
54778   argp1 = (Dali::BaseHandle *)jarg1;
54779   if (!argp1) {
54780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54781     return 0;
54782   }
54783   arg1 = *argp1;
54784   {
54785     try {
54786       result = Dali::Timer::DownCast(arg1);
54787     } catch (std::out_of_range& e) {
54788       {
54789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54790       };
54791     } catch (std::exception& e) {
54792       {
54793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54794       };
54795     } catch (Dali::DaliException e) {
54796       {
54797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54798       };
54799     } catch (...) {
54800       {
54801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54802       };
54803     }
54804   }
54805
54806   jresult = new Dali::Timer((const Dali::Timer &)result);
54807   return jresult;
54808 }
54809
54810
54811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
54812   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54813
54814   arg1 = (Dali::Timer *)jarg1;
54815   {
54816     try {
54817       (arg1)->Start();
54818     } catch (std::out_of_range& e) {
54819       {
54820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54821       };
54822     } catch (std::exception& e) {
54823       {
54824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54825       };
54826     } catch (Dali::DaliException e) {
54827       {
54828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54829       };
54830     } catch (...) {
54831       {
54832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54833       };
54834     }
54835   }
54836
54837 }
54838
54839
54840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
54841   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54842
54843   arg1 = (Dali::Timer *)jarg1;
54844   {
54845     try {
54846       (arg1)->Stop();
54847     } catch (std::out_of_range& e) {
54848       {
54849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54850       };
54851     } catch (std::exception& e) {
54852       {
54853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54854       };
54855     } catch (Dali::DaliException e) {
54856       {
54857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54858       };
54859     } catch (...) {
54860       {
54861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54862       };
54863     }
54864   }
54865
54866 }
54867
54868
54869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
54870   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54871   unsigned int arg2 ;
54872
54873   arg1 = (Dali::Timer *)jarg1;
54874   arg2 = (unsigned int)jarg2;
54875   {
54876     try {
54877       (arg1)->SetInterval(arg2);
54878     } catch (std::out_of_range& e) {
54879       {
54880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54881       };
54882     } catch (std::exception& e) {
54883       {
54884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54885       };
54886     } catch (Dali::DaliException e) {
54887       {
54888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54889       };
54890     } catch (...) {
54891       {
54892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54893       };
54894     }
54895   }
54896
54897 }
54898
54899
54900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
54901   unsigned int jresult ;
54902   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54903   unsigned int result;
54904
54905   arg1 = (Dali::Timer *)jarg1;
54906   {
54907     try {
54908       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
54909     } catch (std::out_of_range& e) {
54910       {
54911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54912       };
54913     } catch (std::exception& e) {
54914       {
54915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54916       };
54917     } catch (Dali::DaliException e) {
54918       {
54919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54920       };
54921     } catch (...) {
54922       {
54923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54924       };
54925     }
54926   }
54927
54928   jresult = result;
54929   return jresult;
54930 }
54931
54932
54933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
54934   unsigned int jresult ;
54935   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54936   bool result;
54937
54938   arg1 = (Dali::Timer *)jarg1;
54939   {
54940     try {
54941       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
54942     } catch (std::out_of_range& e) {
54943       {
54944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54945       };
54946     } catch (std::exception& e) {
54947       {
54948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54949       };
54950     } catch (Dali::DaliException e) {
54951       {
54952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54953       };
54954     } catch (...) {
54955       {
54956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54957       };
54958     }
54959   }
54960
54961   jresult = result;
54962   return jresult;
54963 }
54964
54965
54966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
54967   void * jresult ;
54968   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54969   Dali::Timer::TimerSignalType *result = 0 ;
54970
54971   arg1 = (Dali::Timer *)jarg1;
54972   {
54973     try {
54974       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
54975     } catch (std::out_of_range& e) {
54976       {
54977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54978       };
54979     } catch (std::exception& e) {
54980       {
54981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54982       };
54983     } catch (Dali::DaliException e) {
54984       {
54985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54986       };
54987     } catch (...) {
54988       {
54989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54990       };
54991     }
54992   }
54993
54994   jresult = (void *)result;
54995   return jresult;
54996 }
54997
54998
54999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55000   unsigned int jresult ;
55001   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55002   bool result;
55003
55004   arg1 = (Dali::Signal< bool () > *)jarg1;
55005   {
55006     try {
55007       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
55008     } catch (std::out_of_range& e) {
55009       {
55010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55011       };
55012     } catch (std::exception& e) {
55013       {
55014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55015       };
55016     } catch (Dali::DaliException e) {
55017       {
55018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55019       };
55020     } catch (...) {
55021       {
55022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55023       };
55024     }
55025   }
55026
55027   jresult = result;
55028   return jresult;
55029 }
55030
55031
55032 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55033   unsigned long jresult ;
55034   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55035   std::size_t result;
55036
55037   arg1 = (Dali::Signal< bool () > *)jarg1;
55038   {
55039     try {
55040       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
55041     } catch (std::out_of_range& e) {
55042       {
55043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55044       };
55045     } catch (std::exception& e) {
55046       {
55047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55048       };
55049     } catch (Dali::DaliException e) {
55050       {
55051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55052       };
55053     } catch (...) {
55054       {
55055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55056       };
55057     }
55058   }
55059
55060   jresult = (unsigned long)result;
55061   return jresult;
55062 }
55063
55064
55065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
55066   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55067   bool (*arg2)() = (bool (*)()) 0 ;
55068
55069   arg1 = (Dali::Signal< bool () > *)jarg1;
55070   arg2 = (bool (*)())jarg2;
55071   {
55072     try {
55073       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
55074     } catch (std::out_of_range& e) {
55075       {
55076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55077       };
55078     } catch (std::exception& e) {
55079       {
55080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55081       };
55082     } catch (Dali::DaliException e) {
55083       {
55084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55085       };
55086     } catch (...) {
55087       {
55088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55089       };
55090     }
55091   }
55092
55093 }
55094
55095
55096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55097   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55098   bool (*arg2)() = (bool (*)()) 0 ;
55099
55100   arg1 = (Dali::Signal< bool () > *)jarg1;
55101   arg2 = (bool (*)())jarg2;
55102   {
55103     try {
55104       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55105     } catch (std::out_of_range& e) {
55106       {
55107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55108       };
55109     } catch (std::exception& e) {
55110       {
55111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55112       };
55113     } catch (Dali::DaliException e) {
55114       {
55115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55116       };
55117     } catch (...) {
55118       {
55119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55120       };
55121     }
55122   }
55123
55124 }
55125
55126
55127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55128   unsigned int jresult ;
55129   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55130   bool result;
55131
55132   arg1 = (Dali::Signal< bool () > *)jarg1;
55133   {
55134     try {
55135       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55136     } catch (std::out_of_range& e) {
55137       {
55138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55139       };
55140     } catch (std::exception& e) {
55141       {
55142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55143       };
55144     } catch (Dali::DaliException e) {
55145       {
55146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55147       };
55148     } catch (...) {
55149       {
55150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55151       };
55152     }
55153   }
55154
55155   jresult = result;
55156   return jresult;
55157 }
55158
55159
55160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55161   void * jresult ;
55162   Dali::Signal< bool () > *result = 0 ;
55163
55164   {
55165     try {
55166       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55167     } catch (std::out_of_range& e) {
55168       {
55169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55170       };
55171     } catch (std::exception& e) {
55172       {
55173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55174       };
55175     } catch (Dali::DaliException e) {
55176       {
55177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55178       };
55179     } catch (...) {
55180       {
55181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55182       };
55183     }
55184   }
55185
55186   jresult = (void *)result;
55187   return jresult;
55188 }
55189
55190
55191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55192   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55193
55194   arg1 = (Dali::Signal< bool () > *)jarg1;
55195   {
55196     try {
55197       delete arg1;
55198     } catch (std::out_of_range& e) {
55199       {
55200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55201       };
55202     } catch (std::exception& e) {
55203       {
55204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55205       };
55206     } catch (Dali::DaliException e) {
55207       {
55208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55209       };
55210     } catch (...) {
55211       {
55212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55213       };
55214     }
55215   }
55216
55217 }
55218
55219
55220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55221   int jresult ;
55222   int result;
55223
55224   {
55225     try {
55226       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55227     } catch (std::out_of_range& e) {
55228       {
55229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55230       };
55231     } catch (std::exception& e) {
55232       {
55233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55234       };
55235     } catch (Dali::DaliException e) {
55236       {
55237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55238       };
55239     } catch (...) {
55240       {
55241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55242       };
55243     }
55244   }
55245
55246   jresult = (int)result;
55247   return jresult;
55248 }
55249
55250
55251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55252   int jresult ;
55253   int result;
55254
55255   {
55256     try {
55257       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55258     } catch (std::out_of_range& e) {
55259       {
55260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55261       };
55262     } catch (std::exception& e) {
55263       {
55264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55265       };
55266     } catch (Dali::DaliException e) {
55267       {
55268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55269       };
55270     } catch (...) {
55271       {
55272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55273       };
55274     }
55275   }
55276
55277   jresult = (int)result;
55278   return jresult;
55279 }
55280
55281
55282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55283   int jresult ;
55284   int result;
55285
55286   {
55287     try {
55288       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55289     } catch (std::out_of_range& e) {
55290       {
55291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55292       };
55293     } catch (std::exception& e) {
55294       {
55295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55296       };
55297     } catch (Dali::DaliException e) {
55298       {
55299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55300       };
55301     } catch (...) {
55302       {
55303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55304       };
55305     }
55306   }
55307
55308   jresult = (int)result;
55309   return jresult;
55310 }
55311
55312
55313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55314   int jresult ;
55315   int result;
55316
55317   {
55318     try {
55319       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55320     } catch (std::out_of_range& e) {
55321       {
55322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55323       };
55324     } catch (std::exception& e) {
55325       {
55326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55327       };
55328     } catch (Dali::DaliException e) {
55329       {
55330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55331       };
55332     } catch (...) {
55333       {
55334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55335       };
55336     }
55337   }
55338
55339   jresult = (int)result;
55340   return jresult;
55341 }
55342
55343
55344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55345   int jresult ;
55346   int result;
55347
55348   {
55349     try {
55350       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55351     } catch (std::out_of_range& e) {
55352       {
55353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55354       };
55355     } catch (std::exception& e) {
55356       {
55357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55358       };
55359     } catch (Dali::DaliException e) {
55360       {
55361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55362       };
55363     } catch (...) {
55364       {
55365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55366       };
55367     }
55368   }
55369
55370   jresult = (int)result;
55371   return jresult;
55372 }
55373
55374
55375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55376   int jresult ;
55377   int result;
55378
55379   {
55380     try {
55381       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55382     } catch (std::out_of_range& e) {
55383       {
55384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55385       };
55386     } catch (std::exception& e) {
55387       {
55388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55389       };
55390     } catch (Dali::DaliException e) {
55391       {
55392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55393       };
55394     } catch (...) {
55395       {
55396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55397       };
55398     }
55399   }
55400
55401   jresult = (int)result;
55402   return jresult;
55403 }
55404
55405
55406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55407   int jresult ;
55408   int result;
55409
55410   {
55411     try {
55412       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55413     } catch (std::out_of_range& e) {
55414       {
55415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55416       };
55417     } catch (std::exception& e) {
55418       {
55419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55420       };
55421     } catch (Dali::DaliException e) {
55422       {
55423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55424       };
55425     } catch (...) {
55426       {
55427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55428       };
55429     }
55430   }
55431
55432   jresult = (int)result;
55433   return jresult;
55434 }
55435
55436
55437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55438   int jresult ;
55439   int result;
55440
55441   {
55442     try {
55443       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55444     } catch (std::out_of_range& e) {
55445       {
55446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55447       };
55448     } catch (std::exception& e) {
55449       {
55450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55451       };
55452     } catch (Dali::DaliException e) {
55453       {
55454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55455       };
55456     } catch (...) {
55457       {
55458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55459       };
55460     }
55461   }
55462
55463   jresult = (int)result;
55464   return jresult;
55465 }
55466
55467
55468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55469   int jresult ;
55470   int result;
55471
55472   {
55473     try {
55474       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55475     } catch (std::out_of_range& e) {
55476       {
55477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55478       };
55479     } catch (std::exception& e) {
55480       {
55481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55482       };
55483     } catch (Dali::DaliException e) {
55484       {
55485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55486       };
55487     } catch (...) {
55488       {
55489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55490       };
55491     }
55492   }
55493
55494   jresult = (int)result;
55495   return jresult;
55496 }
55497
55498
55499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
55500   int jresult ;
55501   int result;
55502
55503   {
55504     try {
55505       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55506     } catch (std::out_of_range& e) {
55507       {
55508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55509       };
55510     } catch (std::exception& e) {
55511       {
55512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55513       };
55514     } catch (Dali::DaliException e) {
55515       {
55516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55517       };
55518     } catch (...) {
55519       {
55520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55521       };
55522     }
55523   }
55524
55525   jresult = (int)result;
55526   return jresult;
55527 }
55528
55529
55530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
55531   int jresult ;
55532   int result;
55533
55534   {
55535     try {
55536       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
55537     } catch (std::out_of_range& e) {
55538       {
55539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55540       };
55541     } catch (std::exception& e) {
55542       {
55543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55544       };
55545     } catch (Dali::DaliException e) {
55546       {
55547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55548       };
55549     } catch (...) {
55550       {
55551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55552       };
55553     }
55554   }
55555
55556   jresult = (int)result;
55557   return jresult;
55558 }
55559
55560
55561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
55562   int jresult ;
55563   int result;
55564
55565   {
55566     try {
55567       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
55568     } catch (std::out_of_range& e) {
55569       {
55570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55571       };
55572     } catch (std::exception& e) {
55573       {
55574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55575       };
55576     } catch (Dali::DaliException e) {
55577       {
55578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55579       };
55580     } catch (...) {
55581       {
55582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55583       };
55584     }
55585   }
55586
55587   jresult = (int)result;
55588   return jresult;
55589 }
55590
55591
55592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
55593   int jresult ;
55594   int result;
55595
55596   {
55597     try {
55598       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
55599     } catch (std::out_of_range& e) {
55600       {
55601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55602       };
55603     } catch (std::exception& e) {
55604       {
55605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55606       };
55607     } catch (Dali::DaliException e) {
55608       {
55609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55610       };
55611     } catch (...) {
55612       {
55613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55614       };
55615     }
55616   }
55617
55618   jresult = (int)result;
55619   return jresult;
55620 }
55621
55622
55623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
55624   int jresult ;
55625   int result;
55626
55627   {
55628     try {
55629       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
55630     } catch (std::out_of_range& e) {
55631       {
55632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55633       };
55634     } catch (std::exception& e) {
55635       {
55636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55637       };
55638     } catch (Dali::DaliException e) {
55639       {
55640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55641       };
55642     } catch (...) {
55643       {
55644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55645       };
55646     }
55647   }
55648
55649   jresult = (int)result;
55650   return jresult;
55651 }
55652
55653
55654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
55655   int jresult ;
55656   int result;
55657
55658   {
55659     try {
55660       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
55661     } catch (std::out_of_range& e) {
55662       {
55663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55664       };
55665     } catch (std::exception& e) {
55666       {
55667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55668       };
55669     } catch (Dali::DaliException e) {
55670       {
55671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55672       };
55673     } catch (...) {
55674       {
55675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55676       };
55677     }
55678   }
55679
55680   jresult = (int)result;
55681   return jresult;
55682 }
55683
55684
55685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
55686   int jresult ;
55687   int result;
55688
55689   {
55690     try {
55691       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
55692     } catch (std::out_of_range& e) {
55693       {
55694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55695       };
55696     } catch (std::exception& e) {
55697       {
55698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55699       };
55700     } catch (Dali::DaliException e) {
55701       {
55702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55703       };
55704     } catch (...) {
55705       {
55706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55707       };
55708     }
55709   }
55710
55711   jresult = (int)result;
55712   return jresult;
55713 }
55714
55715
55716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
55717   int jresult ;
55718   int result;
55719
55720   {
55721     try {
55722       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
55723     } catch (std::out_of_range& e) {
55724       {
55725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55726       };
55727     } catch (std::exception& e) {
55728       {
55729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55730       };
55731     } catch (Dali::DaliException e) {
55732       {
55733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55734       };
55735     } catch (...) {
55736       {
55737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55738       };
55739     }
55740   }
55741
55742   jresult = (int)result;
55743   return jresult;
55744 }
55745
55746
55747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
55748   int jresult ;
55749   int result;
55750
55751   {
55752     try {
55753       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
55754     } catch (std::out_of_range& e) {
55755       {
55756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55757       };
55758     } catch (std::exception& e) {
55759       {
55760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55761       };
55762     } catch (Dali::DaliException e) {
55763       {
55764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55765       };
55766     } catch (...) {
55767       {
55768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55769       };
55770     }
55771   }
55772
55773   jresult = (int)result;
55774   return jresult;
55775 }
55776
55777
55778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
55779   int jresult ;
55780   int result;
55781
55782   {
55783     try {
55784       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
55785     } catch (std::out_of_range& e) {
55786       {
55787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55788       };
55789     } catch (std::exception& e) {
55790       {
55791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55792       };
55793     } catch (Dali::DaliException e) {
55794       {
55795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55796       };
55797     } catch (...) {
55798       {
55799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55800       };
55801     }
55802   }
55803
55804   jresult = (int)result;
55805   return jresult;
55806 }
55807
55808
55809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
55810   int jresult ;
55811   int result;
55812
55813   {
55814     try {
55815       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
55816     } catch (std::out_of_range& e) {
55817       {
55818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55819       };
55820     } catch (std::exception& e) {
55821       {
55822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55823       };
55824     } catch (Dali::DaliException e) {
55825       {
55826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55827       };
55828     } catch (...) {
55829       {
55830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55831       };
55832     }
55833   }
55834
55835   jresult = (int)result;
55836   return jresult;
55837 }
55838
55839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
55840   int jresult ;
55841   int result;
55842
55843   {
55844     try {
55845       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
55846     } catch (std::out_of_range& e) {
55847       {
55848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55849       };
55850     } catch (std::exception& e) {
55851       {
55852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55853       };
55854     } catch (Dali::DaliException e) {
55855       {
55856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55857       };
55858     } catch (...) {
55859       {
55860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55861       };
55862     }
55863   }
55864
55865   jresult = (int)result;
55866   return jresult;
55867 }
55868
55869
55870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
55871   int jresult ;
55872   int result;
55873   {
55874     try
55875     {
55876       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
55877     } catch (std::out_of_range& e) {
55878       {
55879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55880       };
55881     } catch (std::exception& e) {
55882       {
55883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55884       };
55885     } catch (Dali::DaliException e) {
55886       {
55887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55888       };
55889     } catch (...) {
55890       {
55891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55892       };
55893     }
55894   }
55895
55896   jresult = (int)result;
55897   return jresult;
55898 }
55899
55900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
55901   int jresult ;
55902   int result;
55903   {
55904     try
55905     {
55906       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
55907     } catch (std::out_of_range& e) {
55908       {
55909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55910       };
55911     } catch (std::exception& e) {
55912       {
55913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55914       };
55915     } catch (Dali::DaliException e) {
55916       {
55917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55918       };
55919     } catch (...) {
55920       {
55921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55922       };
55923     }
55924   }
55925
55926   jresult = (int)result;
55927   return jresult;
55928 }
55929
55930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
55931   int jresult ;
55932   int result;
55933   {
55934     try
55935     {
55936       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
55937     } catch (std::out_of_range& e) {
55938       {
55939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55940       };
55941     } catch (std::exception& e) {
55942       {
55943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55944       };
55945     } catch (Dali::DaliException e) {
55946       {
55947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55948       };
55949     } catch (...) {
55950       {
55951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55952       };
55953     }
55954   }
55955
55956   jresult = (int)result;
55957   return jresult;
55958 }
55959
55960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
55961   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
55962 }
55963
55964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
55965   int jresult ;
55966   int result;
55967   {
55968     try
55969     {
55970       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
55971     } catch (std::out_of_range& e) {
55972       {
55973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55974       };
55975     } catch (std::exception& e) {
55976       {
55977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55978       };
55979     } catch (Dali::DaliException e) {
55980       {
55981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55982       };
55983     } catch (...) {
55984       {
55985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55986       };
55987     }
55988   }
55989
55990   jresult = (int)result;
55991   return jresult;
55992 }
55993
55994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
55995   int jresult ;
55996   int result;
55997   {
55998     try
55999     {
56000       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
56001     } catch (std::out_of_range& e) {
56002       {
56003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56004       };
56005     } catch (std::exception& e) {
56006       {
56007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56008       };
56009     } catch (Dali::DaliException e) {
56010       {
56011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56012       };
56013     } catch (...) {
56014       {
56015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56016       };
56017     }
56018   }
56019
56020   jresult = (int)result;
56021   return jresult;
56022 }
56023
56024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
56025   int jresult ;
56026   int result;
56027
56028   {
56029     try {
56030       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
56031     } catch (std::out_of_range& e) {
56032       {
56033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56034       };
56035     } catch (std::exception& e) {
56036       {
56037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56038       };
56039     } catch (Dali::DaliException e) {
56040       {
56041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56042       };
56043     } catch (...) {
56044       {
56045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56046       };
56047     }
56048   }
56049
56050   jresult = (int)result;
56051   return jresult;
56052 }
56053
56054
56055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
56056   int jresult ;
56057   int result;
56058
56059   {
56060     try {
56061       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
56062     } catch (std::out_of_range& e) {
56063       {
56064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56065       };
56066     } catch (std::exception& e) {
56067       {
56068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56069       };
56070     } catch (Dali::DaliException e) {
56071       {
56072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56073       };
56074     } catch (...) {
56075       {
56076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56077       };
56078     }
56079   }
56080
56081   jresult = (int)result;
56082   return jresult;
56083 }
56084
56085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
56086   int jresult ;
56087   int result;
56088   {
56089     try
56090     {
56091       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
56092     } catch (std::out_of_range& e) {
56093       {
56094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56095       };
56096     } catch (std::exception& e) {
56097       {
56098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56099       };
56100     } catch (...) {
56101       {
56102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56103       };
56104     }
56105   }
56106   jresult = (int)result;
56107   return jresult;
56108 }
56109
56110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
56111   int jresult ;
56112   int result;
56113   {
56114     try
56115     {
56116       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
56117     } catch (std::out_of_range& e) {
56118       {
56119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56120       };
56121     } catch (std::exception& e) {
56122       {
56123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56124       };
56125     } catch (...) {
56126       {
56127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56128       };
56129     }
56130   }
56131   jresult = (int)result;
56132   return jresult;
56133 }
56134
56135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
56136   int jresult ;
56137   int result;
56138   {
56139     try
56140     {
56141       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
56142     } catch (std::out_of_range& e) {
56143       {
56144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56145       };
56146     } catch (std::exception& e) {
56147       {
56148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56149       };
56150     } catch (...) {
56151       {
56152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56153       };
56154     }
56155   }
56156   jresult = (int)result;
56157   return jresult;
56158 }
56159
56160
56161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
56162   int jresult ;
56163   int result;
56164   {
56165     try
56166     {
56167       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
56168     } catch (std::out_of_range& e) {
56169       {
56170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56171       };
56172     } catch (std::exception& e) {
56173       {
56174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56175       };
56176     } catch (...) {
56177       {
56178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56179       };
56180     }
56181   }
56182   jresult = (int)result;
56183   return jresult;
56184 }
56185
56186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
56187   int jresult ;
56188   int result;
56189   {
56190     try
56191     {
56192       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
56193     } catch (std::out_of_range& e) {
56194       {
56195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56196       };
56197     } catch (std::exception& e) {
56198       {
56199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56200       };
56201     } catch (...) {
56202       {
56203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56204       };
56205     }
56206   }
56207   jresult = (int)result;
56208   return jresult;
56209 }
56210
56211
56212
56213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56214   int jresult ;
56215   int result;
56216
56217   {
56218     try {
56219       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56220     } catch (std::out_of_range& e) {
56221       {
56222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56223       };
56224     } catch (std::exception& e) {
56225       {
56226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56227       };
56228     } catch (Dali::DaliException e) {
56229       {
56230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56231       };
56232     } catch (...) {
56233       {
56234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56235       };
56236     }
56237   }
56238
56239   jresult = (int)result;
56240   return jresult;
56241 }
56242
56243
56244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56245   int jresult ;
56246   int result;
56247
56248   {
56249     try {
56250       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56251     } catch (std::out_of_range& e) {
56252       {
56253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56254       };
56255     } catch (std::exception& e) {
56256       {
56257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56258       };
56259     } catch (Dali::DaliException e) {
56260       {
56261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56262       };
56263     } catch (...) {
56264       {
56265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56266       };
56267     }
56268   }
56269
56270   jresult = (int)result;
56271   return jresult;
56272 }
56273
56274
56275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56276   int jresult ;
56277   int result;
56278
56279   {
56280     try {
56281       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56282     } catch (std::out_of_range& e) {
56283       {
56284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56285       };
56286     } catch (std::exception& e) {
56287       {
56288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56289       };
56290     } catch (Dali::DaliException e) {
56291       {
56292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56293       };
56294     } catch (...) {
56295       {
56296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56297       };
56298     }
56299   }
56300
56301   jresult = (int)result;
56302   return jresult;
56303 }
56304
56305
56306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56307   int jresult ;
56308   int result;
56309
56310   {
56311     try {
56312       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56313     } catch (std::out_of_range& e) {
56314       {
56315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56316       };
56317     } catch (std::exception& e) {
56318       {
56319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56320       };
56321     } catch (Dali::DaliException e) {
56322       {
56323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56324       };
56325     } catch (...) {
56326       {
56327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56328       };
56329     }
56330   }
56331
56332   jresult = (int)result;
56333   return jresult;
56334 }
56335
56336
56337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56338   int jresult ;
56339   int result;
56340
56341   {
56342     try {
56343       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56344     } catch (std::out_of_range& e) {
56345       {
56346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56347       };
56348     } catch (std::exception& e) {
56349       {
56350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56351       };
56352     } catch (Dali::DaliException e) {
56353       {
56354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56355       };
56356     } catch (...) {
56357       {
56358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56359       };
56360     }
56361   }
56362
56363   jresult = (int)result;
56364   return jresult;
56365 }
56366
56367
56368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56369   int jresult ;
56370   int result;
56371
56372   {
56373     try {
56374       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56375     } catch (std::out_of_range& e) {
56376       {
56377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56378       };
56379     } catch (std::exception& e) {
56380       {
56381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56382       };
56383     } catch (Dali::DaliException e) {
56384       {
56385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56386       };
56387     } catch (...) {
56388       {
56389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56390       };
56391     }
56392   }
56393
56394   jresult = (int)result;
56395   return jresult;
56396 }
56397
56398
56399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56400   int jresult ;
56401   int result;
56402
56403   {
56404     try {
56405       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56406     } catch (std::out_of_range& e) {
56407       {
56408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56409       };
56410     } catch (std::exception& e) {
56411       {
56412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56413       };
56414     } catch (Dali::DaliException e) {
56415       {
56416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56417       };
56418     } catch (...) {
56419       {
56420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56421       };
56422     }
56423   }
56424
56425   jresult = (int)result;
56426   return jresult;
56427 }
56428
56429 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
56430   int jresult ;
56431   int result;
56432
56433   {
56434     try {
56435       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
56436     } catch (std::out_of_range& e) {
56437       {
56438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56439       };
56440     } catch (std::exception& e) {
56441       {
56442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56443       };
56444     } catch (...) {
56445       {
56446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56447       };
56448     }
56449   }
56450   jresult = (int)result;
56451   return jresult;
56452 }
56453
56454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56455   int jresult ;
56456   int result;
56457
56458   {
56459     try {
56460       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56461     } catch (std::out_of_range& e) {
56462       {
56463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56464       };
56465     } catch (std::exception& e) {
56466       {
56467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56468       };
56469     } catch (Dali::DaliException e) {
56470       {
56471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56472       };
56473     } catch (...) {
56474       {
56475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56476       };
56477     }
56478   }
56479
56480   jresult = (int)result;
56481   return jresult;
56482 }
56483
56484
56485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56486   int jresult ;
56487   int result;
56488
56489   {
56490     try {
56491       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56492     } catch (std::out_of_range& e) {
56493       {
56494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56495       };
56496     } catch (std::exception& e) {
56497       {
56498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56499       };
56500     } catch (Dali::DaliException e) {
56501       {
56502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56503       };
56504     } catch (...) {
56505       {
56506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56507       };
56508     }
56509   }
56510
56511   jresult = (int)result;
56512   return jresult;
56513 }
56514
56515
56516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56517   int jresult ;
56518   int result;
56519
56520   {
56521     try {
56522       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56523     } catch (std::out_of_range& e) {
56524       {
56525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56526       };
56527     } catch (std::exception& e) {
56528       {
56529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56530       };
56531     } catch (Dali::DaliException e) {
56532       {
56533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56534       };
56535     } catch (...) {
56536       {
56537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56538       };
56539     }
56540   }
56541
56542   jresult = (int)result;
56543   return jresult;
56544 }
56545
56546
56547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56548   int jresult ;
56549   int result;
56550
56551   {
56552     try {
56553       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56554     } catch (std::out_of_range& e) {
56555       {
56556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56557       };
56558     } catch (std::exception& e) {
56559       {
56560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56561       };
56562     } catch (Dali::DaliException e) {
56563       {
56564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56565       };
56566     } catch (...) {
56567       {
56568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56569       };
56570     }
56571   }
56572
56573   jresult = (int)result;
56574   return jresult;
56575 }
56576
56577
56578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56579   int jresult ;
56580   int result;
56581
56582   {
56583     try {
56584       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56585     } catch (std::out_of_range& e) {
56586       {
56587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56588       };
56589     } catch (std::exception& e) {
56590       {
56591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56592       };
56593     } catch (Dali::DaliException e) {
56594       {
56595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56596       };
56597     } catch (...) {
56598       {
56599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56600       };
56601     }
56602   }
56603
56604   jresult = (int)result;
56605   return jresult;
56606 }
56607
56608
56609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56610   int jresult ;
56611   int result;
56612
56613   {
56614     try {
56615       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56616     } catch (std::out_of_range& e) {
56617       {
56618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56619       };
56620     } catch (std::exception& e) {
56621       {
56622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56623       };
56624     } catch (Dali::DaliException e) {
56625       {
56626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56627       };
56628     } catch (...) {
56629       {
56630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56631       };
56632     }
56633   }
56634
56635   jresult = (int)result;
56636   return jresult;
56637 }
56638
56639
56640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56641   int jresult ;
56642   int result;
56643
56644   {
56645     try {
56646       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56647     } catch (std::out_of_range& e) {
56648       {
56649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56650       };
56651     } catch (std::exception& e) {
56652       {
56653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56654       };
56655     } catch (Dali::DaliException e) {
56656       {
56657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56658       };
56659     } catch (...) {
56660       {
56661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56662       };
56663     }
56664   }
56665
56666   jresult = (int)result;
56667   return jresult;
56668 }
56669
56670
56671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56672   int jresult ;
56673   int result;
56674
56675   {
56676     try {
56677       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56678     } catch (std::out_of_range& e) {
56679       {
56680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56681       };
56682     } catch (std::exception& e) {
56683       {
56684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56685       };
56686     } catch (Dali::DaliException e) {
56687       {
56688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56689       };
56690     } catch (...) {
56691       {
56692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56693       };
56694     }
56695   }
56696
56697   jresult = (int)result;
56698   return jresult;
56699 }
56700
56701
56702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56703   int jresult ;
56704   int result;
56705
56706   {
56707     try {
56708       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56709     } catch (std::out_of_range& e) {
56710       {
56711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56712       };
56713     } catch (std::exception& e) {
56714       {
56715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56716       };
56717     } catch (Dali::DaliException e) {
56718       {
56719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56720       };
56721     } catch (...) {
56722       {
56723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56724       };
56725     }
56726   }
56727
56728   jresult = (int)result;
56729   return jresult;
56730 }
56731
56732
56733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56734   int jresult ;
56735   int result;
56736
56737   {
56738     try {
56739       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56740     } catch (std::out_of_range& e) {
56741       {
56742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56743       };
56744     } catch (std::exception& e) {
56745       {
56746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56747       };
56748     } catch (Dali::DaliException e) {
56749       {
56750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56751       };
56752     } catch (...) {
56753       {
56754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56755       };
56756     }
56757   }
56758
56759   jresult = (int)result;
56760   return jresult;
56761 }
56762
56763
56764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
56765   int jresult ;
56766   int result;
56767
56768   {
56769     try {
56770       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56771     } catch (std::out_of_range& e) {
56772       {
56773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56774       };
56775     } catch (std::exception& e) {
56776       {
56777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56778       };
56779     } catch (Dali::DaliException e) {
56780       {
56781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56782       };
56783     } catch (...) {
56784       {
56785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56786       };
56787     }
56788   }
56789
56790   jresult = (int)result;
56791   return jresult;
56792 }
56793
56794
56795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
56796   int jresult ;
56797   int result;
56798
56799   {
56800     try {
56801       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56802     } catch (std::out_of_range& e) {
56803       {
56804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56805       };
56806     } catch (std::exception& e) {
56807       {
56808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56809       };
56810     } catch (Dali::DaliException e) {
56811       {
56812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56813       };
56814     } catch (...) {
56815       {
56816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56817       };
56818     }
56819   }
56820
56821   jresult = (int)result;
56822   return jresult;
56823 }
56824
56825
56826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
56827   int jresult ;
56828   int result;
56829
56830   {
56831     try {
56832       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
56833     } catch (std::out_of_range& e) {
56834       {
56835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56836       };
56837     } catch (std::exception& e) {
56838       {
56839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56840       };
56841     } catch (Dali::DaliException e) {
56842       {
56843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56844       };
56845     } catch (...) {
56846       {
56847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56848       };
56849     }
56850   }
56851
56852   jresult = (int)result;
56853   return jresult;
56854 }
56855
56856
56857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
56858   int jresult ;
56859   int result;
56860
56861   {
56862     try {
56863       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
56864     } catch (std::out_of_range& e) {
56865       {
56866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56867       };
56868     } catch (std::exception& e) {
56869       {
56870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56871       };
56872     } catch (Dali::DaliException e) {
56873       {
56874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56875       };
56876     } catch (...) {
56877       {
56878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56879       };
56880     }
56881   }
56882
56883   jresult = (int)result;
56884   return jresult;
56885 }
56886
56887
56888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
56889   int jresult ;
56890   int result;
56891
56892   {
56893     try {
56894       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
56895     } catch (std::out_of_range& e) {
56896       {
56897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56898       };
56899     } catch (std::exception& e) {
56900       {
56901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56902       };
56903     } catch (Dali::DaliException e) {
56904       {
56905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56906       };
56907     } catch (...) {
56908       {
56909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56910       };
56911     }
56912   }
56913
56914   jresult = (int)result;
56915   return jresult;
56916 }
56917
56918
56919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
56920   int jresult ;
56921   int result;
56922
56923   {
56924     try {
56925       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
56926     } catch (std::out_of_range& e) {
56927       {
56928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56929       };
56930     } catch (std::exception& e) {
56931       {
56932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56933       };
56934     } catch (Dali::DaliException e) {
56935       {
56936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56937       };
56938     } catch (...) {
56939       {
56940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56941       };
56942     }
56943   }
56944
56945   jresult = (int)result;
56946   return jresult;
56947 }
56948
56949
56950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
56951   int jresult ;
56952   int result;
56953
56954   {
56955     try {
56956       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
56957     } catch (std::out_of_range& e) {
56958       {
56959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56960       };
56961     } catch (std::exception& e) {
56962       {
56963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56964       };
56965     } catch (Dali::DaliException e) {
56966       {
56967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56968       };
56969     } catch (...) {
56970       {
56971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56972       };
56973     }
56974   }
56975
56976   jresult = (int)result;
56977   return jresult;
56978 }
56979
56980
56981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
56982   int jresult ;
56983   int result;
56984
56985   {
56986     try {
56987       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
56988     } catch (std::out_of_range& e) {
56989       {
56990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56991       };
56992     } catch (std::exception& e) {
56993       {
56994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56995       };
56996     } catch (Dali::DaliException e) {
56997       {
56998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56999       };
57000     } catch (...) {
57001       {
57002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57003       };
57004     }
57005   }
57006
57007   jresult = (int)result;
57008   return jresult;
57009 }
57010
57011
57012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
57013   int jresult ;
57014   int result;
57015
57016   {
57017     try {
57018       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
57019     } catch (std::out_of_range& e) {
57020       {
57021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57022       };
57023     } catch (std::exception& e) {
57024       {
57025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57026       };
57027     } catch (Dali::DaliException e) {
57028       {
57029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57030       };
57031     } catch (...) {
57032       {
57033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57034       };
57035     }
57036   }
57037
57038   jresult = (int)result;
57039   return jresult;
57040 }
57041
57042
57043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
57044   int jresult ;
57045   int result;
57046
57047   {
57048     try {
57049       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
57050     } catch (std::out_of_range& e) {
57051       {
57052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57053       };
57054     } catch (std::exception& e) {
57055       {
57056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57057       };
57058     } catch (Dali::DaliException e) {
57059       {
57060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57061       };
57062     } catch (...) {
57063       {
57064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57065       };
57066     }
57067   }
57068
57069   jresult = (int)result;
57070   return jresult;
57071 }
57072
57073
57074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
57075   int jresult ;
57076   int result;
57077
57078   {
57079     try {
57080       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
57081     } catch (std::out_of_range& e) {
57082       {
57083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57084       };
57085     } catch (std::exception& e) {
57086       {
57087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57088       };
57089     } catch (Dali::DaliException e) {
57090       {
57091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57092       };
57093     } catch (...) {
57094       {
57095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57096       };
57097     }
57098   }
57099
57100   jresult = (int)result;
57101   return jresult;
57102 }
57103
57104
57105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
57106   int jresult ;
57107   int result;
57108
57109   {
57110     try {
57111       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
57112     } catch (std::out_of_range& e) {
57113       {
57114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57115       };
57116     } catch (std::exception& e) {
57117       {
57118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57119       };
57120     } catch (Dali::DaliException e) {
57121       {
57122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57123       };
57124     } catch (...) {
57125       {
57126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57127       };
57128     }
57129   }
57130
57131   jresult = (int)result;
57132   return jresult;
57133 }
57134
57135
57136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
57137   int jresult ;
57138   int result;
57139
57140   {
57141     try {
57142       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
57143     } catch (std::out_of_range& e) {
57144       {
57145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57146       };
57147     } catch (std::exception& e) {
57148       {
57149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57150       };
57151     } catch (Dali::DaliException e) {
57152       {
57153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57154       };
57155     } catch (...) {
57156       {
57157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57158       };
57159     }
57160   }
57161
57162   jresult = (int)result;
57163   return jresult;
57164 }
57165
57166
57167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57168   int jresult ;
57169   int result;
57170
57171   {
57172     try {
57173       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57174     } catch (std::out_of_range& e) {
57175       {
57176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57177       };
57178     } catch (std::exception& e) {
57179       {
57180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57181       };
57182     } catch (Dali::DaliException e) {
57183       {
57184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57185       };
57186     } catch (...) {
57187       {
57188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57189       };
57190     }
57191   }
57192
57193   jresult = (int)result;
57194   return jresult;
57195 }
57196
57197
57198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57199   int jresult ;
57200   int result;
57201
57202   {
57203     try {
57204       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57205     } catch (std::out_of_range& e) {
57206       {
57207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57208       };
57209     } catch (std::exception& e) {
57210       {
57211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57212       };
57213     } catch (Dali::DaliException e) {
57214       {
57215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57216       };
57217     } catch (...) {
57218       {
57219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57220       };
57221     }
57222   }
57223
57224   jresult = (int)result;
57225   return jresult;
57226 }
57227
57228
57229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57230   int jresult ;
57231   int result;
57232
57233   {
57234     try {
57235       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57236     } catch (std::out_of_range& e) {
57237       {
57238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57239       };
57240     } catch (std::exception& e) {
57241       {
57242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57243       };
57244     } catch (Dali::DaliException e) {
57245       {
57246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57247       };
57248     } catch (...) {
57249       {
57250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57251       };
57252     }
57253   }
57254
57255   jresult = (int)result;
57256   return jresult;
57257 }
57258
57259
57260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57261   int jresult ;
57262   int result;
57263
57264   {
57265     try {
57266       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57267     } catch (std::out_of_range& e) {
57268       {
57269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57270       };
57271     } catch (std::exception& e) {
57272       {
57273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57274       };
57275     } catch (Dali::DaliException e) {
57276       {
57277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57278       };
57279     } catch (...) {
57280       {
57281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57282       };
57283     }
57284   }
57285
57286   jresult = (int)result;
57287   return jresult;
57288 }
57289
57290
57291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57292   int jresult ;
57293   int result;
57294
57295   {
57296     try {
57297       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57298     } catch (std::out_of_range& e) {
57299       {
57300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57301       };
57302     } catch (std::exception& e) {
57303       {
57304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57305       };
57306     } catch (Dali::DaliException e) {
57307       {
57308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57309       };
57310     } catch (...) {
57311       {
57312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57313       };
57314     }
57315   }
57316
57317   jresult = (int)result;
57318   return jresult;
57319 }
57320
57321
57322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57323   void * jresult ;
57324   Dali::Toolkit::Builder *result = 0 ;
57325
57326   {
57327     try {
57328       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57329     } catch (std::out_of_range& e) {
57330       {
57331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57332       };
57333     } catch (std::exception& e) {
57334       {
57335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57336       };
57337     } catch (Dali::DaliException e) {
57338       {
57339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57340       };
57341     } catch (...) {
57342       {
57343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57344       };
57345     }
57346   }
57347
57348   jresult = (void *)result;
57349   return jresult;
57350 }
57351
57352
57353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57354   void * jresult ;
57355   Dali::Toolkit::Builder result;
57356
57357   {
57358     try {
57359       result = Dali::Toolkit::Builder::New();
57360     } catch (std::out_of_range& e) {
57361       {
57362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57363       };
57364     } catch (std::exception& e) {
57365       {
57366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57367       };
57368     } catch (Dali::DaliException e) {
57369       {
57370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57371       };
57372     } catch (...) {
57373       {
57374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57375       };
57376     }
57377   }
57378
57379   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57380   return jresult;
57381 }
57382
57383
57384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57385   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57386
57387   arg1 = (Dali::Toolkit::Builder *)jarg1;
57388   {
57389     try {
57390       delete arg1;
57391     } catch (std::out_of_range& e) {
57392       {
57393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57394       };
57395     } catch (std::exception& e) {
57396       {
57397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57398       };
57399     } catch (Dali::DaliException e) {
57400       {
57401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57402       };
57403     } catch (...) {
57404       {
57405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57406       };
57407     }
57408   }
57409
57410 }
57411
57412
57413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57414   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57415   std::string *arg2 = 0 ;
57416   Dali::Toolkit::Builder::UIFormat arg3 ;
57417
57418   arg1 = (Dali::Toolkit::Builder *)jarg1;
57419   if (!jarg2) {
57420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57421     return ;
57422   }
57423   std::string arg2_str(jarg2);
57424   arg2 = &arg2_str;
57425   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57426   {
57427     try {
57428       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57429     } catch (std::out_of_range& e) {
57430       {
57431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57432       };
57433     } catch (std::exception& e) {
57434       {
57435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57436       };
57437     } catch (Dali::DaliException e) {
57438       {
57439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57440       };
57441     } catch (...) {
57442       {
57443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57444       };
57445     }
57446   }
57447
57448
57449   //argout typemap for const std::string&
57450
57451 }
57452
57453
57454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57455   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57456   std::string *arg2 = 0 ;
57457
57458   arg1 = (Dali::Toolkit::Builder *)jarg1;
57459   if (!jarg2) {
57460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57461     return ;
57462   }
57463   std::string arg2_str(jarg2);
57464   arg2 = &arg2_str;
57465   {
57466     try {
57467       (arg1)->LoadFromString((std::string const &)*arg2);
57468     } catch (std::out_of_range& e) {
57469       {
57470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57471       };
57472     } catch (std::exception& e) {
57473       {
57474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57475       };
57476     } catch (Dali::DaliException e) {
57477       {
57478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57479       };
57480     } catch (...) {
57481       {
57482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57483       };
57484     }
57485   }
57486
57487
57488   //argout typemap for const std::string&
57489
57490 }
57491
57492
57493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57494   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57495   Dali::Property::Map *arg2 = 0 ;
57496
57497   arg1 = (Dali::Toolkit::Builder *)jarg1;
57498   arg2 = (Dali::Property::Map *)jarg2;
57499   if (!arg2) {
57500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57501     return ;
57502   }
57503   {
57504     try {
57505       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57506     } catch (std::out_of_range& e) {
57507       {
57508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57509       };
57510     } catch (std::exception& e) {
57511       {
57512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57513       };
57514     } catch (Dali::DaliException e) {
57515       {
57516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57517       };
57518     } catch (...) {
57519       {
57520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57521       };
57522     }
57523   }
57524
57525 }
57526
57527
57528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57529   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57530   std::string *arg2 = 0 ;
57531   Dali::Property::Value *arg3 = 0 ;
57532
57533   arg1 = (Dali::Toolkit::Builder *)jarg1;
57534   if (!jarg2) {
57535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57536     return ;
57537   }
57538   std::string arg2_str(jarg2);
57539   arg2 = &arg2_str;
57540   arg3 = (Dali::Property::Value *)jarg3;
57541   if (!arg3) {
57542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57543     return ;
57544   }
57545   {
57546     try {
57547       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57548     } catch (std::out_of_range& e) {
57549       {
57550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57551       };
57552     } catch (std::exception& e) {
57553       {
57554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57555       };
57556     } catch (Dali::DaliException e) {
57557       {
57558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57559       };
57560     } catch (...) {
57561       {
57562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57563       };
57564     }
57565   }
57566
57567
57568   //argout typemap for const std::string&
57569
57570 }
57571
57572
57573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57574   void * jresult ;
57575   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57576   Dali::Property::Map *result = 0 ;
57577
57578   arg1 = (Dali::Toolkit::Builder *)jarg1;
57579   {
57580     try {
57581       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57582     } catch (std::out_of_range& e) {
57583       {
57584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57585       };
57586     } catch (std::exception& e) {
57587       {
57588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57589       };
57590     } catch (Dali::DaliException e) {
57591       {
57592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57593       };
57594     } catch (...) {
57595       {
57596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57597       };
57598     }
57599   }
57600
57601   jresult = (void *)result;
57602   return jresult;
57603 }
57604
57605
57606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57607   void * jresult ;
57608   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57609   std::string *arg2 = 0 ;
57610   Dali::Property::Value *result = 0 ;
57611
57612   arg1 = (Dali::Toolkit::Builder *)jarg1;
57613   if (!jarg2) {
57614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57615     return 0;
57616   }
57617   std::string arg2_str(jarg2);
57618   arg2 = &arg2_str;
57619   {
57620     try {
57621       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57622     } catch (std::out_of_range& e) {
57623       {
57624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57625       };
57626     } catch (std::exception& e) {
57627       {
57628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57629       };
57630     } catch (Dali::DaliException e) {
57631       {
57632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57633       };
57634     } catch (...) {
57635       {
57636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57637       };
57638     }
57639   }
57640
57641   jresult = (void *)result;
57642
57643   //argout typemap for const std::string&
57644
57645   return jresult;
57646 }
57647
57648
57649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57650   void * jresult ;
57651   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57652   std::string *arg2 = 0 ;
57653   Dali::Animation result;
57654
57655   arg1 = (Dali::Toolkit::Builder *)jarg1;
57656   if (!jarg2) {
57657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57658     return 0;
57659   }
57660   std::string arg2_str(jarg2);
57661   arg2 = &arg2_str;
57662   {
57663     try {
57664       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57665     } catch (std::out_of_range& e) {
57666       {
57667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57668       };
57669     } catch (std::exception& e) {
57670       {
57671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57672       };
57673     } catch (Dali::DaliException e) {
57674       {
57675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57676       };
57677     } catch (...) {
57678       {
57679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57680       };
57681     }
57682   }
57683
57684   jresult = new Dali::Animation((const Dali::Animation &)result);
57685
57686   //argout typemap for const std::string&
57687
57688   return jresult;
57689 }
57690
57691
57692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57693   void * jresult ;
57694   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57695   std::string *arg2 = 0 ;
57696   Dali::Property::Map *arg3 = 0 ;
57697   Dali::Animation result;
57698
57699   arg1 = (Dali::Toolkit::Builder *)jarg1;
57700   if (!jarg2) {
57701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57702     return 0;
57703   }
57704   std::string arg2_str(jarg2);
57705   arg2 = &arg2_str;
57706   arg3 = (Dali::Property::Map *)jarg3;
57707   if (!arg3) {
57708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57709     return 0;
57710   }
57711   {
57712     try {
57713       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57714     } catch (std::out_of_range& e) {
57715       {
57716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57717       };
57718     } catch (std::exception& e) {
57719       {
57720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57721       };
57722     } catch (Dali::DaliException e) {
57723       {
57724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57725       };
57726     } catch (...) {
57727       {
57728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57729       };
57730     }
57731   }
57732
57733   jresult = new Dali::Animation((const Dali::Animation &)result);
57734
57735   //argout typemap for const std::string&
57736
57737   return jresult;
57738 }
57739
57740
57741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57742   void * jresult ;
57743   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57744   std::string *arg2 = 0 ;
57745   Dali::Actor arg3 ;
57746   Dali::Actor *argp3 ;
57747   Dali::Animation result;
57748
57749   arg1 = (Dali::Toolkit::Builder *)jarg1;
57750   if (!jarg2) {
57751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57752     return 0;
57753   }
57754   std::string arg2_str(jarg2);
57755   arg2 = &arg2_str;
57756   argp3 = (Dali::Actor *)jarg3;
57757   if (!argp3) {
57758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57759     return 0;
57760   }
57761   arg3 = *argp3;
57762   {
57763     try {
57764       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57765     } catch (std::out_of_range& e) {
57766       {
57767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57768       };
57769     } catch (std::exception& e) {
57770       {
57771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57772       };
57773     } catch (Dali::DaliException e) {
57774       {
57775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57776       };
57777     } catch (...) {
57778       {
57779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57780       };
57781     }
57782   }
57783
57784   jresult = new Dali::Animation((const Dali::Animation &)result);
57785
57786   //argout typemap for const std::string&
57787
57788   return jresult;
57789 }
57790
57791
57792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57793   void * jresult ;
57794   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57795   std::string *arg2 = 0 ;
57796   Dali::Property::Map *arg3 = 0 ;
57797   Dali::Actor arg4 ;
57798   Dali::Actor *argp4 ;
57799   Dali::Animation result;
57800
57801   arg1 = (Dali::Toolkit::Builder *)jarg1;
57802   if (!jarg2) {
57803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57804     return 0;
57805   }
57806   std::string arg2_str(jarg2);
57807   arg2 = &arg2_str;
57808   arg3 = (Dali::Property::Map *)jarg3;
57809   if (!arg3) {
57810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57811     return 0;
57812   }
57813   argp4 = (Dali::Actor *)jarg4;
57814   if (!argp4) {
57815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57816     return 0;
57817   }
57818   arg4 = *argp4;
57819   {
57820     try {
57821       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57822     } catch (std::out_of_range& e) {
57823       {
57824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57825       };
57826     } catch (std::exception& e) {
57827       {
57828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57829       };
57830     } catch (Dali::DaliException e) {
57831       {
57832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57833       };
57834     } catch (...) {
57835       {
57836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57837       };
57838     }
57839   }
57840
57841   jresult = new Dali::Animation((const Dali::Animation &)result);
57842
57843   //argout typemap for const std::string&
57844
57845   return jresult;
57846 }
57847
57848
57849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
57850   void * jresult ;
57851   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57852   std::string *arg2 = 0 ;
57853   Dali::BaseHandle result;
57854
57855   arg1 = (Dali::Toolkit::Builder *)jarg1;
57856   if (!jarg2) {
57857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57858     return 0;
57859   }
57860   std::string arg2_str(jarg2);
57861   arg2 = &arg2_str;
57862   {
57863     try {
57864       result = (arg1)->Create((std::string const &)*arg2);
57865     } catch (std::out_of_range& e) {
57866       {
57867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57868       };
57869     } catch (std::exception& e) {
57870       {
57871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57872       };
57873     } catch (Dali::DaliException e) {
57874       {
57875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57876       };
57877     } catch (...) {
57878       {
57879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57880       };
57881     }
57882   }
57883
57884   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57885
57886   //argout typemap for const std::string&
57887
57888   return jresult;
57889 }
57890
57891
57892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57893   void * jresult ;
57894   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57895   std::string *arg2 = 0 ;
57896   Dali::Property::Map *arg3 = 0 ;
57897   Dali::BaseHandle result;
57898
57899   arg1 = (Dali::Toolkit::Builder *)jarg1;
57900   if (!jarg2) {
57901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57902     return 0;
57903   }
57904   std::string arg2_str(jarg2);
57905   arg2 = &arg2_str;
57906   arg3 = (Dali::Property::Map *)jarg3;
57907   if (!arg3) {
57908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57909     return 0;
57910   }
57911   {
57912     try {
57913       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57914     } catch (std::out_of_range& e) {
57915       {
57916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57917       };
57918     } catch (std::exception& e) {
57919       {
57920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57921       };
57922     } catch (Dali::DaliException e) {
57923       {
57924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57925       };
57926     } catch (...) {
57927       {
57928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57929       };
57930     }
57931   }
57932
57933   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57934
57935   //argout typemap for const std::string&
57936
57937   return jresult;
57938 }
57939
57940
57941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
57942   void * jresult ;
57943   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57944   std::string *arg2 = 0 ;
57945   Dali::BaseHandle result;
57946
57947   arg1 = (Dali::Toolkit::Builder *)jarg1;
57948   if (!jarg2) {
57949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57950     return 0;
57951   }
57952   std::string arg2_str(jarg2);
57953   arg2 = &arg2_str;
57954   {
57955     try {
57956       result = (arg1)->CreateFromJson((std::string const &)*arg2);
57957     } catch (std::out_of_range& e) {
57958       {
57959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57960       };
57961     } catch (std::exception& e) {
57962       {
57963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57964       };
57965     } catch (Dali::DaliException e) {
57966       {
57967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57968       };
57969     } catch (...) {
57970       {
57971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57972       };
57973     }
57974   }
57975
57976   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57977
57978   //argout typemap for const std::string&
57979
57980   return jresult;
57981 }
57982
57983
57984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
57985   unsigned int jresult ;
57986   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57987   std::string *arg2 = 0 ;
57988   Dali::Handle *arg3 = 0 ;
57989   bool result;
57990
57991   arg1 = (Dali::Toolkit::Builder *)jarg1;
57992   if (!jarg2) {
57993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57994     return 0;
57995   }
57996   std::string arg2_str(jarg2);
57997   arg2 = &arg2_str;
57998   arg3 = (Dali::Handle *)jarg3;
57999   if (!arg3) {
58000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58001     return 0;
58002   }
58003   {
58004     try {
58005       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58006     } catch (std::out_of_range& e) {
58007       {
58008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58009       };
58010     } catch (std::exception& e) {
58011       {
58012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58013       };
58014     } catch (Dali::DaliException e) {
58015       {
58016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58017       };
58018     } catch (...) {
58019       {
58020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58021       };
58022     }
58023   }
58024
58025   jresult = result;
58026
58027   //argout typemap for const std::string&
58028
58029   return jresult;
58030 }
58031
58032
58033 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
58034   unsigned int jresult ;
58035   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58036   Dali::Handle *arg2 = 0 ;
58037   std::string *arg3 = 0 ;
58038   bool result;
58039
58040   arg1 = (Dali::Toolkit::Builder *)jarg1;
58041   arg2 = (Dali::Handle *)jarg2;
58042   if (!arg2) {
58043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58044     return 0;
58045   }
58046   if (!jarg3) {
58047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58048     return 0;
58049   }
58050   std::string arg3_str(jarg3);
58051   arg3 = &arg3_str;
58052   {
58053     try {
58054       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
58055     } catch (std::out_of_range& e) {
58056       {
58057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58058       };
58059     } catch (std::exception& e) {
58060       {
58061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58062       };
58063     } catch (Dali::DaliException e) {
58064       {
58065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58066       };
58067     } catch (...) {
58068       {
58069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58070       };
58071     }
58072   }
58073
58074   jresult = result;
58075
58076   //argout typemap for const std::string&
58077
58078   return jresult;
58079 }
58080
58081
58082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
58083   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58084   Dali::Actor arg2 ;
58085   Dali::Actor *argp2 ;
58086
58087   arg1 = (Dali::Toolkit::Builder *)jarg1;
58088   argp2 = (Dali::Actor *)jarg2;
58089   if (!argp2) {
58090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58091     return ;
58092   }
58093   arg2 = *argp2;
58094   {
58095     try {
58096       (arg1)->AddActors(arg2);
58097     } catch (std::out_of_range& e) {
58098       {
58099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58100       };
58101     } catch (std::exception& e) {
58102       {
58103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58104       };
58105     } catch (Dali::DaliException e) {
58106       {
58107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58108       };
58109     } catch (...) {
58110       {
58111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58112       };
58113     }
58114   }
58115
58116 }
58117
58118
58119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58120   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58121   std::string *arg2 = 0 ;
58122   Dali::Actor arg3 ;
58123   Dali::Actor *argp3 ;
58124
58125   arg1 = (Dali::Toolkit::Builder *)jarg1;
58126   if (!jarg2) {
58127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58128     return ;
58129   }
58130   std::string arg2_str(jarg2);
58131   arg2 = &arg2_str;
58132   argp3 = (Dali::Actor *)jarg3;
58133   if (!argp3) {
58134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58135     return ;
58136   }
58137   arg3 = *argp3;
58138   {
58139     try {
58140       (arg1)->AddActors((std::string const &)*arg2,arg3);
58141     } catch (std::out_of_range& e) {
58142       {
58143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58144       };
58145     } catch (std::exception& e) {
58146       {
58147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58148       };
58149     } catch (Dali::DaliException e) {
58150       {
58151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58152       };
58153     } catch (...) {
58154       {
58155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58156       };
58157     }
58158   }
58159
58160
58161   //argout typemap for const std::string&
58162
58163 }
58164
58165
58166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
58167   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58168   std::string *arg2 = 0 ;
58169
58170   arg1 = (Dali::Toolkit::Builder *)jarg1;
58171   if (!jarg2) {
58172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58173     return ;
58174   }
58175   std::string arg2_str(jarg2);
58176   arg2 = &arg2_str;
58177   {
58178     try {
58179       (arg1)->CreateRenderTask((std::string const &)*arg2);
58180     } catch (std::out_of_range& e) {
58181       {
58182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58183       };
58184     } catch (std::exception& e) {
58185       {
58186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58187       };
58188     } catch (Dali::DaliException e) {
58189       {
58190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58191       };
58192     } catch (...) {
58193       {
58194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58195       };
58196     }
58197   }
58198
58199
58200   //argout typemap for const std::string&
58201
58202 }
58203
58204
58205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58206   void * jresult ;
58207   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58208   std::string *arg2 = 0 ;
58209   Dali::Path result;
58210
58211   arg1 = (Dali::Toolkit::Builder *)jarg1;
58212   if (!jarg2) {
58213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58214     return 0;
58215   }
58216   std::string arg2_str(jarg2);
58217   arg2 = &arg2_str;
58218   {
58219     try {
58220       result = (arg1)->GetPath((std::string const &)*arg2);
58221     } catch (std::out_of_range& e) {
58222       {
58223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58224       };
58225     } catch (std::exception& e) {
58226       {
58227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58228       };
58229     } catch (Dali::DaliException e) {
58230       {
58231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58232       };
58233     } catch (...) {
58234       {
58235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58236       };
58237     }
58238   }
58239
58240   jresult = new Dali::Path((const Dali::Path &)result);
58241
58242   //argout typemap for const std::string&
58243
58244   return jresult;
58245 }
58246
58247
58248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58249   void * jresult ;
58250   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58251   std::string *arg2 = 0 ;
58252   Dali::PathConstrainer result;
58253
58254   arg1 = (Dali::Toolkit::Builder *)jarg1;
58255   if (!jarg2) {
58256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58257     return 0;
58258   }
58259   std::string arg2_str(jarg2);
58260   arg2 = &arg2_str;
58261   {
58262     try {
58263       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58264     } catch (std::out_of_range& e) {
58265       {
58266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58267       };
58268     } catch (std::exception& e) {
58269       {
58270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58271       };
58272     } catch (Dali::DaliException e) {
58273       {
58274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58275       };
58276     } catch (...) {
58277       {
58278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58279       };
58280     }
58281   }
58282
58283   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58284
58285   //argout typemap for const std::string&
58286
58287   return jresult;
58288 }
58289
58290
58291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58292   void * jresult ;
58293   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58294   std::string *arg2 = 0 ;
58295   Dali::LinearConstrainer result;
58296
58297   arg1 = (Dali::Toolkit::Builder *)jarg1;
58298   if (!jarg2) {
58299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58300     return 0;
58301   }
58302   std::string arg2_str(jarg2);
58303   arg2 = &arg2_str;
58304   {
58305     try {
58306       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58307     } catch (std::out_of_range& e) {
58308       {
58309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58310       };
58311     } catch (std::exception& e) {
58312       {
58313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58314       };
58315     } catch (Dali::DaliException e) {
58316       {
58317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58318       };
58319     } catch (...) {
58320       {
58321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58322       };
58323     }
58324   }
58325
58326   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58327
58328   //argout typemap for const std::string&
58329
58330   return jresult;
58331 }
58332
58333
58334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58335   void * jresult ;
58336   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58337   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58338
58339   arg1 = (Dali::Toolkit::Builder *)jarg1;
58340   {
58341     try {
58342       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58343     } catch (std::out_of_range& e) {
58344       {
58345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58346       };
58347     } catch (std::exception& e) {
58348       {
58349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58350       };
58351     } catch (Dali::DaliException e) {
58352       {
58353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58354       };
58355     } catch (...) {
58356       {
58357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58358       };
58359     }
58360   }
58361
58362   jresult = (void *)result;
58363   return jresult;
58364 }
58365
58366
58367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58368   void * jresult ;
58369   Dali::Toolkit::TransitionData *result = 0 ;
58370
58371   {
58372     try {
58373       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58374     } catch (std::out_of_range& e) {
58375       {
58376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58377       };
58378     } catch (std::exception& e) {
58379       {
58380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58381       };
58382     } catch (Dali::DaliException e) {
58383       {
58384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58385       };
58386     } catch (...) {
58387       {
58388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58389       };
58390     }
58391   }
58392
58393   jresult = (void *)result;
58394   return jresult;
58395 }
58396
58397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58398   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58399
58400   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58401   {
58402     try {
58403       delete arg1;
58404     } catch (std::out_of_range& e) {
58405       {
58406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58407       };
58408     } catch (std::exception& e) {
58409       {
58410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58411       };
58412     } catch (Dali::DaliException e) {
58413       {
58414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58415       };
58416     } catch (...) {
58417       {
58418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58419       };
58420     }
58421   }
58422
58423 }
58424
58425
58426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58427   void * jresult ;
58428   Dali::Property::Map *arg1 = 0 ;
58429   Dali::Toolkit::TransitionData result;
58430
58431   arg1 = (Dali::Property::Map *)jarg1;
58432   if (!arg1) {
58433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58434     return 0;
58435   }
58436   {
58437     try {
58438       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58439     } catch (std::out_of_range& e) {
58440       {
58441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58442       };
58443     } catch (std::exception& e) {
58444       {
58445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58446       };
58447     } catch (Dali::DaliException e) {
58448       {
58449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58450       };
58451     } catch (...) {
58452       {
58453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58454       };
58455     }
58456   }
58457
58458   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58459   return jresult;
58460 }
58461
58462
58463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58464   void * jresult ;
58465   Dali::Property::Array *arg1 = 0 ;
58466   Dali::Toolkit::TransitionData result;
58467
58468   arg1 = (Dali::Property::Array *)jarg1;
58469   if (!arg1) {
58470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58471     return 0;
58472   }
58473   {
58474     try {
58475       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58476     } catch (std::out_of_range& e) {
58477       {
58478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58479       };
58480     } catch (std::exception& e) {
58481       {
58482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58483       };
58484     } catch (Dali::DaliException e) {
58485       {
58486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58487       };
58488     } catch (...) {
58489       {
58490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58491       };
58492     }
58493   }
58494
58495   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58496   return jresult;
58497 }
58498
58499
58500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58501   void * jresult ;
58502   Dali::BaseHandle arg1 ;
58503   Dali::BaseHandle *argp1 ;
58504   Dali::Toolkit::TransitionData result;
58505
58506   argp1 = (Dali::BaseHandle *)jarg1;
58507   if (!argp1) {
58508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58509     return 0;
58510   }
58511   arg1 = *argp1;
58512   {
58513     try {
58514       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58515     } catch (std::out_of_range& e) {
58516       {
58517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58518       };
58519     } catch (std::exception& e) {
58520       {
58521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58522       };
58523     } catch (Dali::DaliException e) {
58524       {
58525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58526       };
58527     } catch (...) {
58528       {
58529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58530       };
58531     }
58532   }
58533
58534   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58535   return jresult;
58536 }
58537
58538
58539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58540   void * jresult ;
58541   Dali::Toolkit::TransitionData *arg1 = 0 ;
58542   Dali::Toolkit::TransitionData *result = 0 ;
58543
58544   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58545   if (!arg1) {
58546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58547     return 0;
58548   }
58549   {
58550     try {
58551       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58552     } catch (std::out_of_range& e) {
58553       {
58554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58555       };
58556     } catch (std::exception& e) {
58557       {
58558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58559       };
58560     } catch (Dali::DaliException e) {
58561       {
58562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58563       };
58564     } catch (...) {
58565       {
58566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58567       };
58568     }
58569   }
58570
58571   jresult = (void *)result;
58572   return jresult;
58573 }
58574
58575
58576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58577   void * jresult ;
58578   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58579   Dali::Toolkit::TransitionData *arg2 = 0 ;
58580   Dali::Toolkit::TransitionData *result = 0 ;
58581
58582   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58583   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58584   if (!arg2) {
58585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58586     return 0;
58587   }
58588   {
58589     try {
58590       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58591     } catch (std::out_of_range& e) {
58592       {
58593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58594       };
58595     } catch (std::exception& e) {
58596       {
58597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58598       };
58599     } catch (Dali::DaliException e) {
58600       {
58601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58602       };
58603     } catch (...) {
58604       {
58605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58606       };
58607     }
58608   }
58609
58610   jresult = (void *)result;
58611   return jresult;
58612 }
58613
58614
58615 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58616   unsigned long jresult ;
58617   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58618   size_t result;
58619
58620   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58621   {
58622     try {
58623       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58624     } catch (std::out_of_range& e) {
58625       {
58626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58627       };
58628     } catch (std::exception& e) {
58629       {
58630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58631       };
58632     } catch (Dali::DaliException e) {
58633       {
58634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58635       };
58636     } catch (...) {
58637       {
58638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58639       };
58640     }
58641   }
58642
58643   jresult = (unsigned long)result;
58644   return jresult;
58645 }
58646
58647
58648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58649   void * jresult ;
58650   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58651   size_t arg2 ;
58652   Dali::Property::Map result;
58653
58654   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58655   arg2 = (size_t)jarg2;
58656   {
58657     try {
58658       result = (arg1)->GetAnimatorAt(arg2);
58659     } catch (std::out_of_range& e) {
58660       {
58661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58662       };
58663     } catch (std::exception& e) {
58664       {
58665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58666       };
58667     } catch (Dali::DaliException e) {
58668       {
58669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58670       };
58671     } catch (...) {
58672       {
58673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58674       };
58675     }
58676   }
58677
58678   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58679   return jresult;
58680 }
58681
58682
58683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58684   int jresult ;
58685   int result;
58686
58687   {
58688     try {
58689       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58690     } catch (std::out_of_range& e) {
58691       {
58692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58693       };
58694     } catch (std::exception& e) {
58695       {
58696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58697       };
58698     } catch (Dali::DaliException e) {
58699       {
58700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58701       };
58702     } catch (...) {
58703       {
58704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58705       };
58706     }
58707   }
58708
58709   jresult = (int)result;
58710   return jresult;
58711 }
58712
58713
58714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58715   int jresult ;
58716   int result;
58717
58718   {
58719     try {
58720       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58721     } catch (std::out_of_range& e) {
58722       {
58723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58724       };
58725     } catch (std::exception& e) {
58726       {
58727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58728       };
58729     } catch (Dali::DaliException e) {
58730       {
58731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58732       };
58733     } catch (...) {
58734       {
58735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58736       };
58737     }
58738   }
58739
58740   jresult = (int)result;
58741   return jresult;
58742 }
58743
58744
58745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58746   int jresult ;
58747   int result;
58748
58749   {
58750     try {
58751       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58752     } catch (std::out_of_range& e) {
58753       {
58754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58755       };
58756     } catch (std::exception& e) {
58757       {
58758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58759       };
58760     } catch (Dali::DaliException e) {
58761       {
58762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58763       };
58764     } catch (...) {
58765       {
58766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58767       };
58768     }
58769   }
58770
58771   jresult = (int)result;
58772   return jresult;
58773 }
58774
58775
58776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58777   int jresult ;
58778   int result;
58779
58780   {
58781     try {
58782       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58783     } catch (std::out_of_range& e) {
58784       {
58785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58786       };
58787     } catch (std::exception& e) {
58788       {
58789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58790       };
58791     } catch (Dali::DaliException e) {
58792       {
58793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58794       };
58795     } catch (...) {
58796       {
58797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58798       };
58799     }
58800   }
58801
58802   jresult = (int)result;
58803   return jresult;
58804 }
58805
58806
58807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58808   int jresult ;
58809   int result;
58810
58811   {
58812     try {
58813       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58814     } catch (std::out_of_range& e) {
58815       {
58816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58817       };
58818     } catch (std::exception& e) {
58819       {
58820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58821       };
58822     } catch (Dali::DaliException e) {
58823       {
58824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58825       };
58826     } catch (...) {
58827       {
58828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58829       };
58830     }
58831   }
58832
58833   jresult = (int)result;
58834   return jresult;
58835 }
58836
58837
58838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58839   int jresult ;
58840   int result;
58841
58842   {
58843     try {
58844       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
58845     } catch (std::out_of_range& e) {
58846       {
58847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58848       };
58849     } catch (std::exception& e) {
58850       {
58851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58852       };
58853     } catch (Dali::DaliException e) {
58854       {
58855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58856       };
58857     } catch (...) {
58858       {
58859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58860       };
58861     }
58862   }
58863
58864   jresult = (int)result;
58865   return jresult;
58866 }
58867
58868
58869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
58870   int jresult ;
58871   int result;
58872
58873   {
58874     try {
58875       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
58876     } catch (std::out_of_range& e) {
58877       {
58878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58879       };
58880     } catch (std::exception& e) {
58881       {
58882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58883       };
58884     } catch (Dali::DaliException e) {
58885       {
58886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58887       };
58888     } catch (...) {
58889       {
58890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58891       };
58892     }
58893   }
58894
58895   jresult = (int)result;
58896   return jresult;
58897 }
58898
58899
58900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
58901   int jresult ;
58902   int result;
58903
58904   {
58905     try {
58906       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
58907     } catch (std::out_of_range& e) {
58908       {
58909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58910       };
58911     } catch (std::exception& e) {
58912       {
58913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58914       };
58915     } catch (Dali::DaliException e) {
58916       {
58917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58918       };
58919     } catch (...) {
58920       {
58921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58922       };
58923     }
58924   }
58925
58926   jresult = (int)result;
58927   return jresult;
58928 }
58929
58930
58931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
58932   int jresult ;
58933   int result;
58934
58935   {
58936     try {
58937       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
58938     } catch (std::out_of_range& e) {
58939       {
58940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58941       };
58942     } catch (std::exception& e) {
58943       {
58944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58945       };
58946     } catch (Dali::DaliException e) {
58947       {
58948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58949       };
58950     } catch (...) {
58951       {
58952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58953       };
58954     }
58955   }
58956
58957   jresult = (int)result;
58958   return jresult;
58959 }
58960
58961
58962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
58963   int jresult ;
58964   int result;
58965
58966   {
58967     try {
58968       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
58969     } catch (std::out_of_range& e) {
58970       {
58971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58972       };
58973     } catch (std::exception& e) {
58974       {
58975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58976       };
58977     } catch (Dali::DaliException e) {
58978       {
58979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58980       };
58981     } catch (...) {
58982       {
58983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58984       };
58985     }
58986   }
58987
58988   jresult = (int)result;
58989   return jresult;
58990 }
58991
58992
58993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
58994   int jresult ;
58995   int result;
58996
58997   {
58998     try {
58999       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
59000     } catch (std::out_of_range& e) {
59001       {
59002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59003       };
59004     } catch (std::exception& e) {
59005       {
59006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59007       };
59008     } catch (Dali::DaliException e) {
59009       {
59010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59011       };
59012     } catch (...) {
59013       {
59014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59015       };
59016     }
59017   }
59018
59019   jresult = (int)result;
59020   return jresult;
59021 }
59022
59023
59024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59025   int jresult ;
59026   int result;
59027
59028   {
59029     try {
59030       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59031     } catch (std::out_of_range& e) {
59032       {
59033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59034       };
59035     } catch (std::exception& e) {
59036       {
59037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59038       };
59039     } catch (Dali::DaliException e) {
59040       {
59041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59042       };
59043     } catch (...) {
59044       {
59045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59046       };
59047     }
59048   }
59049
59050   jresult = (int)result;
59051   return jresult;
59052 }
59053
59054
59055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59056   int jresult ;
59057   int result;
59058
59059   {
59060     try {
59061       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59062     } catch (std::out_of_range& e) {
59063       {
59064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59065       };
59066     } catch (std::exception& e) {
59067       {
59068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59069       };
59070     } catch (Dali::DaliException e) {
59071       {
59072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59073       };
59074     } catch (...) {
59075       {
59076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59077       };
59078     }
59079   }
59080
59081   jresult = (int)result;
59082   return jresult;
59083 }
59084
59085
59086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
59087   int jresult ;
59088   int result;
59089
59090   {
59091     try {
59092       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
59093     } catch (std::out_of_range& e) {
59094       {
59095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59096       };
59097     } catch (std::exception& e) {
59098       {
59099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59100       };
59101     } catch (Dali::DaliException e) {
59102       {
59103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59104       };
59105     } catch (...) {
59106       {
59107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59108       };
59109     }
59110   }
59111
59112   jresult = (int)result;
59113   return jresult;
59114 }
59115
59116
59117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59118   void * jresult ;
59119   Dali::Toolkit::Control result;
59120
59121   {
59122     try {
59123       result = Dali::Toolkit::Internal::Control::New();
59124     } catch (std::out_of_range& e) {
59125       {
59126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59127       };
59128     } catch (std::exception& e) {
59129       {
59130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59131       };
59132     } catch (Dali::DaliException e) {
59133       {
59134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59135       };
59136     } catch (...) {
59137       {
59138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59139       };
59140     }
59141   }
59142
59143   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59144   return jresult;
59145 }
59146
59147
59148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59149   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59150   std::string *arg2 = 0 ;
59151
59152   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59153   if (!jarg2) {
59154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59155     return ;
59156   }
59157   std::string arg2_str(jarg2);
59158   arg2 = &arg2_str;
59159   {
59160     try {
59161       (arg1)->SetStyleName((std::string const &)*arg2);
59162     } catch (std::out_of_range& e) {
59163       {
59164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59165       };
59166     } catch (std::exception& e) {
59167       {
59168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59169       };
59170     } catch (Dali::DaliException e) {
59171       {
59172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59173       };
59174     } catch (...) {
59175       {
59176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59177       };
59178     }
59179   }
59180
59181
59182   //argout typemap for const std::string&
59183
59184 }
59185
59186
59187 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59188   char * jresult ;
59189   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59190   std::string *result = 0 ;
59191
59192   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59193   {
59194     try {
59195       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59196     } catch (std::out_of_range& e) {
59197       {
59198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59199       };
59200     } catch (std::exception& e) {
59201       {
59202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59203       };
59204     } catch (Dali::DaliException e) {
59205       {
59206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59207       };
59208     } catch (...) {
59209       {
59210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59211       };
59212     }
59213   }
59214
59215   jresult = SWIG_csharp_string_callback(result->c_str());
59216   return jresult;
59217 }
59218
59219
59220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59221   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59222   Dali::Vector4 *arg2 = 0 ;
59223
59224   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59225   arg2 = (Dali::Vector4 *)jarg2;
59226   if (!arg2) {
59227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59228     return ;
59229   }
59230   {
59231     try {
59232       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59233     } catch (std::out_of_range& e) {
59234       {
59235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59236       };
59237     } catch (std::exception& e) {
59238       {
59239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59240       };
59241     } catch (Dali::DaliException e) {
59242       {
59243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59244       };
59245     } catch (...) {
59246       {
59247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59248       };
59249     }
59250   }
59251
59252 }
59253
59254
59255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
59256   void * jresult ;
59257   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
59258   Dali::Vector4 result;
59259
59260   arg1 = (Dali::Handle *)jarg1;
59261   {
59262     try {
59263       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
59264       if (resultMap)
59265       {
59266         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
59267         if(type && type->Get<int>() == Visual::COLOR )
59268         {
59269           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
59270           if (value)
59271           {
59272             result = value->Get<Vector4>();
59273           }
59274         }
59275       }
59276     } catch (std::out_of_range& e) {
59277       {
59278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59279       };
59280     } catch (std::exception& e) {
59281       {
59282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59283       };
59284     } catch (Dali::DaliException e) {
59285       {
59286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59287       };
59288     } catch (...) {
59289       {
59290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59291       };
59292     }
59293   }
59294
59295   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59296   return jresult;
59297 }
59298
59299
59300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59301   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59302   Dali::Property::Map *arg2 = 0 ;
59303
59304   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59305   arg2 = (Dali::Property::Map *)jarg2;
59306   if (!arg2) {
59307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59308     return ;
59309   }
59310   {
59311     try {
59312       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59313     } catch (std::out_of_range& e) {
59314       {
59315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59316       };
59317     } catch (std::exception& e) {
59318       {
59319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59320       };
59321     } catch (Dali::DaliException e) {
59322       {
59323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59324       };
59325     } catch (...) {
59326       {
59327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59328       };
59329     }
59330   }
59331
59332 }
59333
59334
59335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59336   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59337
59338   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59339   {
59340     try {
59341       (arg1)->ClearBackground();
59342     } catch (std::out_of_range& e) {
59343       {
59344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59345       };
59346     } catch (std::exception& e) {
59347       {
59348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59349       };
59350     } catch (Dali::DaliException e) {
59351       {
59352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59353       };
59354     } catch (...) {
59355       {
59356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59357       };
59358     }
59359   }
59360
59361 }
59362
59363
59364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59365   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59366   Dali::Gesture::Type arg2 ;
59367
59368   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59369   arg2 = (Dali::Gesture::Type)jarg2;
59370   {
59371     try {
59372       (arg1)->EnableGestureDetection(arg2);
59373     } catch (std::out_of_range& e) {
59374       {
59375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59376       };
59377     } catch (std::exception& e) {
59378       {
59379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59380       };
59381     } catch (Dali::DaliException e) {
59382       {
59383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59384       };
59385     } catch (...) {
59386       {
59387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59388       };
59389     }
59390   }
59391
59392 }
59393
59394
59395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59396   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59397   Dali::Gesture::Type arg2 ;
59398
59399   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59400   arg2 = (Dali::Gesture::Type)jarg2;
59401   {
59402     try {
59403       (arg1)->DisableGestureDetection(arg2);
59404     } catch (std::out_of_range& e) {
59405       {
59406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59407       };
59408     } catch (std::exception& e) {
59409       {
59410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59411       };
59412     } catch (Dali::DaliException e) {
59413       {
59414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59415       };
59416     } catch (...) {
59417       {
59418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59419       };
59420     }
59421   }
59422
59423 }
59424
59425
59426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59427   void * jresult ;
59428   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59429   Dali::PinchGestureDetector result;
59430
59431   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59432   {
59433     try {
59434       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59435     } catch (std::out_of_range& e) {
59436       {
59437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59438       };
59439     } catch (std::exception& e) {
59440       {
59441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59442       };
59443     } catch (Dali::DaliException e) {
59444       {
59445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59446       };
59447     } catch (...) {
59448       {
59449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59450       };
59451     }
59452   }
59453
59454   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59455   return jresult;
59456 }
59457
59458
59459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59460   void * jresult ;
59461   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59462   Dali::PanGestureDetector result;
59463
59464   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59465   {
59466     try {
59467       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59468     } catch (std::out_of_range& e) {
59469       {
59470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59471       };
59472     } catch (std::exception& e) {
59473       {
59474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59475       };
59476     } catch (Dali::DaliException e) {
59477       {
59478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59479       };
59480     } catch (...) {
59481       {
59482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59483       };
59484     }
59485   }
59486
59487   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59488   return jresult;
59489 }
59490
59491
59492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59493   void * jresult ;
59494   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59495   Dali::TapGestureDetector result;
59496
59497   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59498   {
59499     try {
59500       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59501     } catch (std::out_of_range& e) {
59502       {
59503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59504       };
59505     } catch (std::exception& e) {
59506       {
59507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59508       };
59509     } catch (Dali::DaliException e) {
59510       {
59511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59512       };
59513     } catch (...) {
59514       {
59515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59516       };
59517     }
59518   }
59519
59520   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59521   return jresult;
59522 }
59523
59524
59525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59526   void * jresult ;
59527   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59528   Dali::LongPressGestureDetector result;
59529
59530   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59531   {
59532     try {
59533       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59534     } catch (std::out_of_range& e) {
59535       {
59536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59537       };
59538     } catch (std::exception& e) {
59539       {
59540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59541       };
59542     } catch (Dali::DaliException e) {
59543       {
59544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59545       };
59546     } catch (...) {
59547       {
59548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59549       };
59550     }
59551   }
59552
59553   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59554   return jresult;
59555 }
59556
59557
59558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59559   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59560   bool arg2 ;
59561
59562   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59563   arg2 = jarg2 ? true : false;
59564   {
59565     try {
59566       (arg1)->SetKeyboardNavigationSupport(arg2);
59567     } catch (std::out_of_range& e) {
59568       {
59569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59570       };
59571     } catch (std::exception& e) {
59572       {
59573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59574       };
59575     } catch (Dali::DaliException e) {
59576       {
59577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59578       };
59579     } catch (...) {
59580       {
59581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59582       };
59583     }
59584   }
59585
59586 }
59587
59588
59589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59590   unsigned int jresult ;
59591   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59592   bool result;
59593
59594   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59595   {
59596     try {
59597       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59598     } catch (std::out_of_range& e) {
59599       {
59600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59601       };
59602     } catch (std::exception& e) {
59603       {
59604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59605       };
59606     } catch (Dali::DaliException e) {
59607       {
59608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59609       };
59610     } catch (...) {
59611       {
59612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59613       };
59614     }
59615   }
59616
59617   jresult = result;
59618   return jresult;
59619 }
59620
59621
59622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59623   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59624
59625   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59626   {
59627     try {
59628       (arg1)->SetKeyInputFocus();
59629     } catch (std::out_of_range& e) {
59630       {
59631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59632       };
59633     } catch (std::exception& e) {
59634       {
59635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59636       };
59637     } catch (Dali::DaliException e) {
59638       {
59639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59640       };
59641     } catch (...) {
59642       {
59643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59644       };
59645     }
59646   }
59647
59648 }
59649
59650
59651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
59652   unsigned int jresult ;
59653   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59654   bool result;
59655
59656   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59657   {
59658     try {
59659       result = (bool)(arg1)->HasKeyInputFocus();
59660     } catch (std::out_of_range& e) {
59661       {
59662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59663       };
59664     } catch (std::exception& e) {
59665       {
59666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59667       };
59668     } catch (Dali::DaliException e) {
59669       {
59670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59671       };
59672     } catch (...) {
59673       {
59674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59675       };
59676     }
59677   }
59678
59679   jresult = result;
59680   return jresult;
59681 }
59682
59683
59684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
59685   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59686
59687   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59688   {
59689     try {
59690       (arg1)->ClearKeyInputFocus();
59691     } catch (std::out_of_range& e) {
59692       {
59693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59694       };
59695     } catch (std::exception& e) {
59696       {
59697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59698       };
59699     } catch (Dali::DaliException e) {
59700       {
59701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59702       };
59703     } catch (...) {
59704       {
59705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59706       };
59707     }
59708   }
59709
59710 }
59711
59712
59713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
59714   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59715   bool arg2 ;
59716
59717   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59718   arg2 = jarg2 ? true : false;
59719   {
59720     try {
59721       (arg1)->SetAsKeyboardFocusGroup(arg2);
59722     } catch (std::out_of_range& e) {
59723       {
59724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59725       };
59726     } catch (std::exception& e) {
59727       {
59728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59729       };
59730     } catch (Dali::DaliException e) {
59731       {
59732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59733       };
59734     } catch (...) {
59735       {
59736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59737       };
59738     }
59739   }
59740
59741 }
59742
59743
59744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
59745   unsigned int jresult ;
59746   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59747   bool result;
59748
59749   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59750   {
59751     try {
59752       result = (bool)(arg1)->IsKeyboardFocusGroup();
59753     } catch (std::out_of_range& e) {
59754       {
59755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59756       };
59757     } catch (std::exception& e) {
59758       {
59759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59760       };
59761     } catch (Dali::DaliException e) {
59762       {
59763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59764       };
59765     } catch (...) {
59766       {
59767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59768       };
59769     }
59770   }
59771
59772   jresult = result;
59773   return jresult;
59774 }
59775
59776
59777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59778   void * jresult ;
59779   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59780   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59781
59782   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59783   {
59784     try {
59785       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59786     } catch (std::out_of_range& e) {
59787       {
59788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59789       };
59790     } catch (std::exception& e) {
59791       {
59792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59793       };
59794     } catch (Dali::DaliException e) {
59795       {
59796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59797       };
59798     } catch (...) {
59799       {
59800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59801       };
59802     }
59803   }
59804
59805   jresult = (void *)result;
59806   return jresult;
59807 }
59808
59809
59810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59811   void * jresult ;
59812   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59813   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59814
59815   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59816   {
59817     try {
59818       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59819     } catch (std::out_of_range& e) {
59820       {
59821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59822       };
59823     } catch (std::exception& e) {
59824       {
59825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59826       };
59827     } catch (Dali::DaliException e) {
59828       {
59829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59830       };
59831     } catch (...) {
59832       {
59833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59834       };
59835     }
59836   }
59837
59838   jresult = (void *)result;
59839   return jresult;
59840 }
59841
59842
59843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59844   void * jresult ;
59845   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59846   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59847
59848   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59849   {
59850     try {
59851       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59852     } catch (std::out_of_range& e) {
59853       {
59854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59855       };
59856     } catch (std::exception& e) {
59857       {
59858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59859       };
59860     } catch (Dali::DaliException e) {
59861       {
59862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59863       };
59864     } catch (...) {
59865       {
59866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59867       };
59868     }
59869   }
59870
59871   jresult = (void *)result;
59872   return jresult;
59873 }
59874
59875
59876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
59877   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59878   int arg2 ;
59879   SwigDirector_ViewImpl *darg = 0;
59880
59881   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59882   arg2 = (int)jarg2;
59883   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59884   if(!darg) {
59885     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59886     return;
59887   }
59888   {
59889     try {
59890       if(darg) {
59891         (darg)->OnSceneConnection(arg2);
59892       }
59893     } catch (std::out_of_range& e) {
59894       {
59895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59896       };
59897     } catch (std::exception& e) {
59898       {
59899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59900       };
59901     } catch (Dali::DaliException e) {
59902       {
59903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59904       };
59905     } catch (...) {
59906       {
59907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59908       };
59909     }
59910   }
59911
59912 }
59913
59914
59915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
59916   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59917   int arg2 ;
59918   SwigDirector_ViewImpl *darg = 0;
59919
59920   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59921   arg2 = (int)jarg2;
59922   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59923   if(!darg) {
59924     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59925     return;
59926   }
59927   {
59928     try {
59929       if(darg) {
59930         (darg)->OnSceneConnectionSwigPublic(arg2);
59931       }
59932     } catch (std::out_of_range& e) {
59933       {
59934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59935       };
59936     } catch (std::exception& e) {
59937       {
59938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59939       };
59940     } catch (Dali::DaliException e) {
59941       {
59942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59943       };
59944     } catch (...) {
59945       {
59946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59947       };
59948     }
59949   }
59950
59951 }
59952
59953
59954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
59955   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59956   SwigDirector_ViewImpl *darg = 0;
59957
59958   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59959   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59960   if(!darg) {
59961     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59962     return;
59963   }
59964   {
59965     try {
59966       if(darg) {
59967         (darg)->OnSceneDisconnection();
59968       }
59969     } catch (std::out_of_range& e) {
59970       {
59971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59972       };
59973     } catch (std::exception& e) {
59974       {
59975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59976       };
59977     } catch (Dali::DaliException e) {
59978       {
59979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59980       };
59981     } catch (...) {
59982       {
59983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59984       };
59985     }
59986   }
59987
59988 }
59989
59990
59991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
59992   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59993   SwigDirector_ViewImpl *darg = 0;
59994
59995   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59996   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59997   if(!darg) {
59998     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59999     return;
60000   }
60001   {
60002     try {
60003       if(darg) {
60004         (darg)->OnSceneDisconnectionSwigPublic();
60005       }
60006     } catch (std::out_of_range& e) {
60007       {
60008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60009       };
60010     } catch (std::exception& e) {
60011       {
60012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60013       };
60014     } catch (Dali::DaliException e) {
60015       {
60016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60017       };
60018     } catch (...) {
60019       {
60020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60021       };
60022     }
60023   }
60024
60025 }
60026
60027
60028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60030   Dali::Actor *arg2 = 0 ;
60031   SwigDirector_ViewImpl *darg = 0;
60032
60033   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60034   arg2 = (Dali::Actor *)jarg2;
60035   if (!arg2) {
60036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60037     return ;
60038   }
60039   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60040   if(!darg) {
60041     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60042     return;
60043   }
60044   {
60045     try {
60046       if(darg) {
60047         (darg)->OnChildAdd(*arg2);
60048       }
60049     } catch (std::out_of_range& e) {
60050       {
60051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60052       };
60053     } catch (std::exception& e) {
60054       {
60055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60056       };
60057     } catch (Dali::DaliException e) {
60058       {
60059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60060       };
60061     } catch (...) {
60062       {
60063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60064       };
60065     }
60066   }
60067
60068 }
60069
60070
60071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60072   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60073   Dali::Actor *arg2 = 0 ;
60074   SwigDirector_ViewImpl *darg = 0;
60075
60076   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60077   arg2 = (Dali::Actor *)jarg2;
60078   if (!arg2) {
60079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60080     return ;
60081   }
60082   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60083   if(!darg) {
60084     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60085     return;
60086   }
60087   {
60088     try {
60089       if(darg) {
60090           (darg)->OnChildAddSwigPublic(*arg2);
60091       }
60092     } catch (std::out_of_range& e) {
60093       {
60094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60095       };
60096     } catch (std::exception& e) {
60097       {
60098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60099       };
60100     } catch (Dali::DaliException e) {
60101       {
60102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60103       };
60104     } catch (...) {
60105       {
60106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60107       };
60108     }
60109   }
60110
60111 }
60112
60113
60114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60115   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60116   Dali::Actor *arg2 = 0 ;
60117   SwigDirector_ViewImpl *darg = 0;
60118
60119   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60120   arg2 = (Dali::Actor *)jarg2;
60121   if (!arg2) {
60122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60123     return ;
60124   }
60125   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60126   if(!darg) {
60127     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60128     return;
60129   }
60130   {
60131     try {
60132       if(darg) {
60133         (darg)->OnChildRemove(*arg2);
60134       }
60135     } catch (std::out_of_range& e) {
60136       {
60137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60138       };
60139     } catch (std::exception& e) {
60140       {
60141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60142       };
60143     } catch (Dali::DaliException e) {
60144       {
60145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60146       };
60147     } catch (...) {
60148       {
60149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60150       };
60151     }
60152   }
60153
60154 }
60155
60156
60157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60158   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60159   Dali::Actor *arg2 = 0 ;
60160   SwigDirector_ViewImpl *darg = 0;
60161
60162   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60163   arg2 = (Dali::Actor *)jarg2;
60164   if (!arg2) {
60165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60166     return ;
60167   }
60168   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60169   if(!darg) {
60170     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60171     return;
60172   }
60173   {
60174     try {
60175       if(darg) {
60176         (darg)->OnChildRemoveSwigPublic(*arg2);
60177       }
60178     } catch (std::out_of_range& e) {
60179       {
60180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60181       };
60182     } catch (std::exception& e) {
60183       {
60184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60185       };
60186     } catch (Dali::DaliException e) {
60187       {
60188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60189       };
60190     } catch (...) {
60191       {
60192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60193       };
60194     }
60195   }
60196
60197 }
60198
60199
60200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60201   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60202   Dali::Property::Index arg2 ;
60203   Dali::Property::Value arg3 ;
60204   Dali::Property::Value *argp3 ;
60205   SwigDirector_ViewImpl *darg = 0;
60206
60207   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60208   arg2 = (Dali::Property::Index)jarg2;
60209   argp3 = (Dali::Property::Value *)jarg3;
60210   if (!argp3) {
60211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60212     return ;
60213   }
60214   arg3 = *argp3;
60215   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60216   if (!darg) {
60217     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60218     return;
60219   }
60220   {
60221     try {
60222       (darg)->OnPropertySet(arg2,arg3);
60223     } catch (std::out_of_range& e) {
60224       {
60225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60226       };
60227     } catch (std::exception& e) {
60228       {
60229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60230       };
60231     } catch (Dali::DaliException e) {
60232       {
60233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60234       };
60235     } catch (...) {
60236       {
60237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60238       };
60239     }
60240   }
60241
60242 }
60243
60244
60245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60246   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60247   Dali::Property::Index arg2 ;
60248   Dali::Property::Value arg3 ;
60249   Dali::Property::Value *argp3 ;
60250   SwigDirector_ViewImpl *darg = 0;
60251
60252   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60253   arg2 = (Dali::Property::Index)jarg2;
60254   argp3 = (Dali::Property::Value *)jarg3;
60255   if (!argp3) {
60256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60257     return ;
60258   }
60259   arg3 = *argp3;
60260   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60261   if (!darg) {
60262     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60263     return;
60264   }
60265   {
60266     try {
60267       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60268     } catch (std::out_of_range& e) {
60269       {
60270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60271       };
60272     } catch (std::exception& e) {
60273       {
60274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60275       };
60276     } catch (Dali::DaliException e) {
60277       {
60278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60279       };
60280     } catch (...) {
60281       {
60282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60283       };
60284     }
60285   }
60286
60287 }
60288
60289
60290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60291   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60292   Dali::Vector3 *arg2 = 0 ;
60293   SwigDirector_ViewImpl *darg = 0;
60294
60295   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60296   arg2 = (Dali::Vector3 *)jarg2;
60297   if (!arg2) {
60298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60299     return ;
60300   }
60301   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60302   if (!darg) {
60303     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60304     return;
60305   }
60306   {
60307     try {
60308       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60309     } catch (std::out_of_range& e) {
60310       {
60311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60312       };
60313     } catch (std::exception& e) {
60314       {
60315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60316       };
60317     } catch (Dali::DaliException e) {
60318       {
60319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60320       };
60321     } catch (...) {
60322       {
60323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60324       };
60325     }
60326   }
60327
60328 }
60329
60330
60331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60332   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60333   Dali::Vector3 *arg2 = 0 ;
60334   SwigDirector_ViewImpl *darg = 0;
60335
60336   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60337   arg2 = (Dali::Vector3 *)jarg2;
60338   if (!arg2) {
60339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60340     return ;
60341   }
60342   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60343   if (!darg) {
60344     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60345     return;
60346   }
60347   {
60348     try {
60349       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60350     } catch (std::out_of_range& e) {
60351       {
60352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60353       };
60354     } catch (std::exception& e) {
60355       {
60356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60357       };
60358     } catch (Dali::DaliException e) {
60359       {
60360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60361       };
60362     } catch (...) {
60363       {
60364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60365       };
60366     }
60367   }
60368
60369 }
60370
60371
60372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60373   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60374   Dali::Animation *arg2 = 0 ;
60375   Dali::Vector3 *arg3 = 0 ;
60376   SwigDirector_ViewImpl *darg = 0;
60377
60378   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60379   arg2 = (Dali::Animation *)jarg2;
60380   if (!arg2) {
60381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60382     return ;
60383   }
60384   arg3 = (Dali::Vector3 *)jarg3;
60385   if (!arg3) {
60386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60387     return ;
60388   }
60389   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60390   if (!darg) {
60391     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60392     return;
60393   }
60394   {
60395     try {
60396       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60397     } catch (std::out_of_range& e) {
60398       {
60399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60400       };
60401     } catch (std::exception& e) {
60402       {
60403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60404       };
60405     } catch (Dali::DaliException e) {
60406       {
60407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60408       };
60409     } catch (...) {
60410       {
60411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60412       };
60413     }
60414   }
60415
60416 }
60417
60418
60419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60420   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60421   Dali::Animation *arg2 = 0 ;
60422   Dali::Vector3 *arg3 = 0 ;
60423   SwigDirector_ViewImpl *darg = 0;
60424
60425   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60426   arg2 = (Dali::Animation *)jarg2;
60427   if (!arg2) {
60428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60429     return ;
60430   }
60431   arg3 = (Dali::Vector3 *)jarg3;
60432   if (!arg3) {
60433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60434     return ;
60435   }
60436   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60437   if (!darg) {
60438     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60439     return;
60440   }
60441   {
60442     try {
60443       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60444     } catch (std::out_of_range& e) {
60445       {
60446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60447       };
60448     } catch (std::exception& e) {
60449       {
60450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60451       };
60452     } catch (Dali::DaliException e) {
60453       {
60454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60455       };
60456     } catch (...) {
60457       {
60458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60459       };
60460     }
60461   }
60462 }
60463
60464
60465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60466   unsigned int jresult ;
60467   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60468   Dali::HoverEvent *arg2 = 0 ;
60469   SwigDirector_ViewImpl *darg = 0;
60470   bool result;
60471
60472   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60473   arg2 = (Dali::HoverEvent *)jarg2;
60474   if (!arg2) {
60475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60476     return 0;
60477   }
60478   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60479   if (!darg) {
60480     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60481     return 0;
60482   }
60483   {
60484     try {
60485       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60486     } catch (std::out_of_range& e) {
60487       {
60488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60489       };
60490     } catch (std::exception& e) {
60491       {
60492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60493       };
60494     } catch (Dali::DaliException e) {
60495       {
60496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60497       };
60498     } catch (...) {
60499       {
60500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60501       };
60502     }
60503   }
60504
60505   jresult = result;
60506   return jresult;
60507 }
60508
60509
60510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60511   unsigned int jresult ;
60512   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60513   Dali::HoverEvent *arg2 = 0 ;
60514   SwigDirector_ViewImpl *darg = 0;
60515   bool result;
60516
60517   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60518   arg2 = (Dali::HoverEvent *)jarg2;
60519   if (!arg2) {
60520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60521     return 0;
60522   }
60523   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60524   if (!darg) {
60525     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60526     return 0;
60527   }
60528   {
60529     try {
60530       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60531     } catch (std::out_of_range& e) {
60532       {
60533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60534       };
60535     } catch (std::exception& e) {
60536       {
60537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60538       };
60539     } catch (Dali::DaliException e) {
60540       {
60541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60542       };
60543     } catch (...) {
60544       {
60545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60546       };
60547     }
60548   }
60549
60550   jresult = result;
60551   return jresult;
60552 }
60553
60554
60555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60556   unsigned int jresult ;
60557   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60558   Dali::KeyEvent *arg2 = 0 ;
60559   SwigDirector_ViewImpl *darg = 0;
60560   bool result;
60561
60562   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60563   arg2 = (Dali::KeyEvent *)jarg2;
60564   if (!arg2) {
60565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60566     return 0;
60567   }
60568   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60569   if (!darg) {
60570     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60571     return 0;
60572   }
60573   {
60574     try {
60575       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60576     } catch (std::out_of_range& e) {
60577       {
60578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60579       };
60580     } catch (std::exception& e) {
60581       {
60582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60583       };
60584     } catch (Dali::DaliException e) {
60585       {
60586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60587       };
60588     } catch (...) {
60589       {
60590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60591       };
60592     }
60593   }
60594
60595   jresult = result;
60596   return jresult;
60597 }
60598
60599
60600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60601   unsigned int jresult ;
60602   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60603   Dali::KeyEvent *arg2 = 0 ;
60604   SwigDirector_ViewImpl *darg = 0;
60605   bool result;
60606
60607   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60608   arg2 = (Dali::KeyEvent *)jarg2;
60609   if (!arg2) {
60610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60611     return 0;
60612   }
60613   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60614   if (!darg) {
60615     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60616     return 0;
60617   }
60618   {
60619     try {
60620       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60621     } catch (std::out_of_range& e) {
60622       {
60623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60624       };
60625     } catch (std::exception& e) {
60626       {
60627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60628       };
60629     } catch (Dali::DaliException e) {
60630       {
60631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60632       };
60633     } catch (...) {
60634       {
60635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60636       };
60637     }
60638   }
60639
60640   jresult = result;
60641   return jresult;
60642 }
60643
60644
60645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60646   unsigned int jresult ;
60647   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60648   Dali::WheelEvent *arg2 = 0 ;
60649   SwigDirector_ViewImpl *darg = 0;
60650   bool result;
60651
60652   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60653   arg2 = (Dali::WheelEvent *)jarg2;
60654   if (!arg2) {
60655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60656     return 0;
60657   }
60658   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60659   if (!darg) {
60660     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60661     return 0;
60662   }
60663   {
60664     try {
60665       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
60666     } catch (std::out_of_range& e) {
60667       {
60668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60669       };
60670     } catch (std::exception& e) {
60671       {
60672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60673       };
60674     } catch (Dali::DaliException e) {
60675       {
60676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60677       };
60678     } catch (...) {
60679       {
60680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60681       };
60682     }
60683   }
60684
60685   jresult = result;
60686   return jresult;
60687 }
60688
60689
60690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60691   unsigned int jresult ;
60692   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60693   Dali::WheelEvent *arg2 = 0 ;
60694   SwigDirector_ViewImpl *darg = 0;
60695   bool result;
60696
60697   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60698   arg2 = (Dali::WheelEvent *)jarg2;
60699   if (!arg2) {
60700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60701     return 0;
60702   }
60703   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60704   if (!darg) {
60705     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60706     return 0;
60707   }
60708   {
60709     try {
60710       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
60711     } catch (std::out_of_range& e) {
60712       {
60713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60714       };
60715     } catch (std::exception& e) {
60716       {
60717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60718       };
60719     } catch (Dali::DaliException e) {
60720       {
60721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60722       };
60723     } catch (...) {
60724       {
60725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60726       };
60727     }
60728   }
60729
60730   jresult = result;
60731   return jresult;
60732 }
60733
60734
60735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
60736   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60737   Dali::Vector2 *arg2 = 0 ;
60738   Dali::RelayoutContainer *arg3 = 0 ;
60739   SwigDirector_ViewImpl *darg = 0;
60740
60741   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60742   arg2 = (Dali::Vector2 *)jarg2;
60743   if (!arg2) {
60744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60745     return ;
60746   }
60747   arg3 = (Dali::RelayoutContainer *)jarg3;
60748   if (!arg3) {
60749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60750     return ;
60751   }
60752   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60753   if (!darg) {
60754     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60755     return;
60756   }
60757   {
60758     try {
60759       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
60760     } catch (std::out_of_range& e) {
60761       {
60762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60763       };
60764     } catch (std::exception& e) {
60765       {
60766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60767       };
60768     } catch (Dali::DaliException e) {
60769       {
60770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60771       };
60772     } catch (...) {
60773       {
60774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60775       };
60776     }
60777   }
60778
60779 }
60780
60781
60782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60783   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60784   Dali::Vector2 *arg2 = 0 ;
60785   Dali::RelayoutContainer *arg3 = 0 ;
60786   SwigDirector_ViewImpl *darg = 0;
60787
60788   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60789   arg2 = (Dali::Vector2 *)jarg2;
60790   if (!arg2) {
60791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60792     return ;
60793   }
60794   arg3 = (Dali::RelayoutContainer *)jarg3;
60795   if (!arg3) {
60796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60797     return ;
60798   }
60799   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60800   if (!darg) {
60801     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60802     return;
60803   }
60804   {
60805     try {
60806       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
60807     } catch (std::out_of_range& e) {
60808       {
60809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60810       };
60811     } catch (std::exception& e) {
60812       {
60813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60814       };
60815     } catch (Dali::DaliException e) {
60816       {
60817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60818       };
60819     } catch (...) {
60820       {
60821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60822       };
60823     }
60824   }
60825
60826 }
60827
60828
60829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
60830   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60831   Dali::ResizePolicy::Type arg2 ;
60832   Dali::Dimension::Type arg3 ;
60833   SwigDirector_ViewImpl *darg = 0;
60834
60835   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60836   arg2 = (Dali::ResizePolicy::Type)jarg2;
60837   arg3 = (Dali::Dimension::Type)jarg3;
60838   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60839   if (!darg) {
60840     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60841     return;
60842   }
60843   {
60844     try {
60845       (darg)->OnSetResizePolicy(arg2,arg3);
60846     } catch (std::out_of_range& e) {
60847       {
60848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60849       };
60850     } catch (std::exception& e) {
60851       {
60852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60853       };
60854     } catch (Dali::DaliException e) {
60855       {
60856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60857       };
60858     } catch (...) {
60859       {
60860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60861       };
60862     }
60863   }
60864
60865 }
60866
60867
60868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
60869   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60870   Dali::ResizePolicy::Type arg2 ;
60871   Dali::Dimension::Type arg3 ;
60872   SwigDirector_ViewImpl *darg = 0;
60873
60874   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60875   arg2 = (Dali::ResizePolicy::Type)jarg2;
60876   arg3 = (Dali::Dimension::Type)jarg3;
60877   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60878   if (!darg) {
60879     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60880     return;
60881   }
60882   {
60883     try {
60884       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
60885     } catch (std::out_of_range& e) {
60886       {
60887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60888       };
60889     } catch (std::exception& e) {
60890       {
60891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60892       };
60893     } catch (Dali::DaliException e) {
60894       {
60895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60896       };
60897     } catch (...) {
60898       {
60899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60900       };
60901     }
60902   }
60903
60904 }
60905
60906
60907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
60908   void * jresult ;
60909   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60910   SwigDirector_ViewImpl *darg = 0;
60911   Dali::Vector3 result;
60912
60913   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60914   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60915   if (!darg) {
60916     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60917     return 0;
60918   }
60919   {
60920     try {
60921       result = (darg)->GetNaturalSize();
60922     } catch (std::out_of_range& e) {
60923       {
60924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60925       };
60926     } catch (std::exception& e) {
60927       {
60928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60929       };
60930     } catch (Dali::DaliException e) {
60931       {
60932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60933       };
60934     } catch (...) {
60935       {
60936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60937       };
60938     }
60939   }
60940
60941   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60942   return jresult;
60943 }
60944
60945
60946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
60947   void * jresult ;
60948   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60949   SwigDirector_ViewImpl *darg = 0;
60950   Dali::Vector3 result;
60951
60952   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60953   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60954   if (!darg) {
60955     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60956     return 0;
60957   }
60958   {
60959     try {
60960       result = (darg)->GetNaturalSizeSwigPublic();
60961     } catch (std::out_of_range& e) {
60962       {
60963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60964       };
60965     } catch (std::exception& e) {
60966       {
60967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60968       };
60969     } catch (Dali::DaliException e) {
60970       {
60971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60972       };
60973     } catch (...) {
60974       {
60975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60976       };
60977     }
60978   }
60979
60980   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60981   return jresult;
60982 }
60983
60984
60985 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
60986   float jresult ;
60987   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60988   Dali::Actor *arg2 = 0 ;
60989   Dali::Dimension::Type arg3 ;
60990   SwigDirector_ViewImpl *darg = 0;
60991   float result;
60992
60993   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60994   arg2 = (Dali::Actor *)jarg2;
60995   if (!arg2) {
60996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60997     return 0;
60998   }
60999   arg3 = (Dali::Dimension::Type)jarg3;
61000   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61001   if (!darg) {
61002     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61003     return 0;
61004   }
61005   {
61006     try {
61007       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61008     } catch (std::out_of_range& e) {
61009       {
61010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61011       };
61012     } catch (std::exception& e) {
61013       {
61014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61015       };
61016     } catch (Dali::DaliException e) {
61017       {
61018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61019       };
61020     } catch (...) {
61021       {
61022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61023       };
61024     }
61025   }
61026
61027   jresult = result;
61028   return jresult;
61029 }
61030
61031
61032 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61033   float jresult ;
61034   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61035   Dali::Actor *arg2 = 0 ;
61036   Dali::Dimension::Type arg3 ;
61037   SwigDirector_ViewImpl *darg = 0;
61038   float result;
61039
61040   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61041   arg2 = (Dali::Actor *)jarg2;
61042   if (!arg2) {
61043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61044     return 0;
61045   }
61046   arg3 = (Dali::Dimension::Type)jarg3;
61047   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61048   if (!darg) {
61049     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61050     return 0;
61051   }
61052   {
61053     try {
61054       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61055     } catch (std::out_of_range& e) {
61056       {
61057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61058       };
61059     } catch (std::exception& e) {
61060       {
61061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61062       };
61063     } catch (Dali::DaliException e) {
61064       {
61065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61066       };
61067     } catch (...) {
61068       {
61069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61070       };
61071     }
61072   }
61073
61074   jresult = result;
61075   return jresult;
61076 }
61077
61078
61079 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61080   float jresult ;
61081   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61082   float arg2 ;
61083   SwigDirector_ViewImpl *darg = 0;
61084   float result;
61085
61086   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61087   arg2 = (float)jarg2;
61088   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61089   if (!darg) {
61090     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61091     return 0;
61092   }
61093   {
61094     try {
61095       result = (float)(darg)->GetHeightForWidth(arg2);
61096     } catch (std::out_of_range& e) {
61097       {
61098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61099       };
61100     } catch (std::exception& e) {
61101       {
61102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61103       };
61104     } catch (Dali::DaliException e) {
61105       {
61106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61107       };
61108     } catch (...) {
61109       {
61110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61111       };
61112     }
61113   }
61114
61115   jresult = result;
61116   return jresult;
61117 }
61118
61119
61120 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61121   float jresult ;
61122   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61123   float arg2 ;
61124   SwigDirector_ViewImpl *darg = 0;
61125   float result;
61126
61127   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61128   arg2 = (float)jarg2;
61129   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61130   if (!darg) {
61131     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61132     return 0;
61133   }
61134   {
61135     try {
61136       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61137     } catch (std::out_of_range& e) {
61138       {
61139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61140       };
61141     } catch (std::exception& e) {
61142       {
61143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61144       };
61145     } catch (Dali::DaliException e) {
61146       {
61147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61148       };
61149     } catch (...) {
61150       {
61151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61152       };
61153     }
61154   }
61155
61156   jresult = result;
61157   return jresult;
61158 }
61159
61160
61161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61162   float jresult ;
61163   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61164   float arg2 ;
61165   SwigDirector_ViewImpl *darg = 0;
61166   float result;
61167
61168   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61169   arg2 = (float)jarg2;
61170   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61171   if (!darg) {
61172     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61173     return 0;
61174   }
61175   {
61176     try {
61177       result = (float)(darg)->GetWidthForHeight(arg2);
61178     } catch (std::out_of_range& e) {
61179       {
61180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61181       };
61182     } catch (std::exception& e) {
61183       {
61184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61185       };
61186     } catch (Dali::DaliException e) {
61187       {
61188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61189       };
61190     } catch (...) {
61191       {
61192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61193       };
61194     }
61195   }
61196
61197   jresult = result;
61198   return jresult;
61199 }
61200
61201
61202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61203   float jresult ;
61204   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61205   float arg2 ;
61206   SwigDirector_ViewImpl *darg = 0;
61207   float result;
61208
61209   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61210   arg2 = (float)jarg2;
61211   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61212   if (!darg) {
61213     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61214     return 0;
61215   }
61216   {
61217     try {
61218       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61219     } catch (std::out_of_range& e) {
61220       {
61221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61222       };
61223     } catch (std::exception& e) {
61224       {
61225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61226       };
61227     } catch (Dali::DaliException e) {
61228       {
61229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61230       };
61231     } catch (...) {
61232       {
61233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61234       };
61235     }
61236   }
61237
61238   jresult = result;
61239   return jresult;
61240 }
61241
61242
61243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61244   unsigned int jresult ;
61245   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61246   Dali::Dimension::Type arg2 ;
61247   SwigDirector_ViewImpl *darg = 0;
61248   bool result;
61249
61250   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61251   arg2 = (Dali::Dimension::Type)jarg2;
61252   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61253   if (!darg) {
61254     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61255     return 0;
61256   }
61257   {
61258     try {
61259       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61260     } catch (std::out_of_range& e) {
61261       {
61262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61263       };
61264     } catch (std::exception& e) {
61265       {
61266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61267       };
61268     } catch (Dali::DaliException e) {
61269       {
61270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61271       };
61272     } catch (...) {
61273       {
61274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61275       };
61276     }
61277   }
61278
61279   jresult = result;
61280   return jresult;
61281 }
61282
61283
61284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61285   unsigned int jresult ;
61286   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61287   Dali::Dimension::Type arg2 ;
61288   SwigDirector_ViewImpl *darg = 0;
61289   bool result;
61290
61291   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61292   arg2 = (Dali::Dimension::Type)jarg2;
61293   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61294   if (!darg) {
61295     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61296     return 0;
61297   }
61298   {
61299     try {
61300       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61301     } catch (std::out_of_range& e) {
61302       {
61303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61304       };
61305     } catch (std::exception& e) {
61306       {
61307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61308       };
61309     } catch (Dali::DaliException e) {
61310       {
61311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61312       };
61313     } catch (...) {
61314       {
61315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61316       };
61317     }
61318   }
61319
61320   jresult = result;
61321   return jresult;
61322 }
61323
61324
61325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61326   unsigned int jresult ;
61327   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61328   SwigDirector_ViewImpl *darg = 0;
61329   bool result;
61330
61331   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61332   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61333   if (!darg) {
61334     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61335     return 0;
61336   }
61337   {
61338     try {
61339       result = (bool)(darg)->RelayoutDependentOnChildren();
61340     } catch (std::out_of_range& e) {
61341       {
61342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61343       };
61344     } catch (std::exception& e) {
61345       {
61346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61347       };
61348     } catch (Dali::DaliException e) {
61349       {
61350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61351       };
61352     } catch (...) {
61353       {
61354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61355       };
61356     }
61357   }
61358
61359   jresult = result;
61360   return jresult;
61361 }
61362
61363
61364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61365   unsigned int jresult ;
61366   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61367   SwigDirector_ViewImpl *darg = 0;
61368   bool result;
61369
61370   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61371   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61372   if (!darg) {
61373     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61374     return 0;
61375   }
61376   {
61377     try {
61378       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61379     } catch (std::out_of_range& e) {
61380       {
61381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61382       };
61383     } catch (std::exception& e) {
61384       {
61385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61386       };
61387     } catch (Dali::DaliException e) {
61388       {
61389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61390       };
61391     } catch (...) {
61392       {
61393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61394       };
61395     }
61396   }
61397
61398   jresult = result;
61399   return jresult;
61400 }
61401
61402
61403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61404   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61405   Dali::Dimension::Type arg2 ;
61406   SwigDirector_ViewImpl *darg = 0;
61407
61408   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61409   arg2 = (Dali::Dimension::Type)jarg2;
61410   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61411   if (!darg) {
61412     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61413     return;
61414   }
61415   {
61416     try {
61417       (darg)->OnCalculateRelayoutSize(arg2);
61418     } catch (std::out_of_range& e) {
61419       {
61420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61421       };
61422     } catch (std::exception& e) {
61423       {
61424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61425       };
61426     } catch (Dali::DaliException e) {
61427       {
61428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61429       };
61430     } catch (...) {
61431       {
61432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61433       };
61434     }
61435   }
61436
61437 }
61438
61439
61440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61441   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61442   Dali::Dimension::Type arg2 ;
61443   SwigDirector_ViewImpl *darg = 0;
61444
61445   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61446   arg2 = (Dali::Dimension::Type)jarg2;
61447   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61448   if (!darg) {
61449     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61450     return;
61451   }
61452   {
61453     try {
61454       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61455     } catch (std::out_of_range& e) {
61456       {
61457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61458       };
61459     } catch (std::exception& e) {
61460       {
61461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61462       };
61463     } catch (Dali::DaliException e) {
61464       {
61465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61466       };
61467     } catch (...) {
61468       {
61469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61470       };
61471     }
61472   }
61473
61474 }
61475
61476
61477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61478   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61479   float arg2 ;
61480   Dali::Dimension::Type arg3 ;
61481   SwigDirector_ViewImpl *darg = 0;
61482
61483   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61484   arg2 = (float)jarg2;
61485   arg3 = (Dali::Dimension::Type)jarg3;
61486   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61487   if (!darg) {
61488     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61489     return;
61490   }
61491   {
61492     try {
61493       (darg)->OnLayoutNegotiated(arg2,arg3);
61494     } catch (std::out_of_range& e) {
61495       {
61496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61497       };
61498     } catch (std::exception& e) {
61499       {
61500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61501       };
61502     } catch (Dali::DaliException e) {
61503       {
61504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61505       };
61506     } catch (...) {
61507       {
61508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61509       };
61510     }
61511   }
61512
61513 }
61514
61515
61516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61517   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61518   float arg2 ;
61519   Dali::Dimension::Type arg3 ;
61520   SwigDirector_ViewImpl *darg = 0;
61521
61522   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61523   arg2 = (float)jarg2;
61524   arg3 = (Dali::Dimension::Type)jarg3;
61525   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61526   if (!darg) {
61527     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61528     return;
61529   }
61530   {
61531     try {
61532       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61533     } catch (std::out_of_range& e) {
61534       {
61535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61536       };
61537     } catch (std::exception& e) {
61538       {
61539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61540       };
61541     } catch (Dali::DaliException e) {
61542       {
61543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61544       };
61545     } catch (...) {
61546       {
61547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61548       };
61549     }
61550   }
61551
61552 }
61553
61554
61555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
61556   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61557
61558   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61559   {
61560     try {
61561       (arg1)->OnInitialize();
61562     } catch (std::out_of_range& e) {
61563       {
61564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61565       };
61566     } catch (std::exception& e) {
61567       {
61568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61569       };
61570     } catch (Dali::DaliException e) {
61571       {
61572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61573       };
61574     } catch (...) {
61575       {
61576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61577       };
61578     }
61579   }
61580
61581 }
61582
61583
61584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61585   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61586
61587   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61588   {
61589     try {
61590       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61591     } catch (std::out_of_range& e) {
61592       {
61593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61594       };
61595     } catch (std::exception& e) {
61596       {
61597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61598       };
61599     } catch (Dali::DaliException e) {
61600       {
61601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61602       };
61603     } catch (...) {
61604       {
61605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61606       };
61607     }
61608   }
61609
61610 }
61611
61612
61613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61614   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61615   Dali::Toolkit::StyleManager arg2 ;
61616   Dali::StyleChange::Type arg3 ;
61617   Dali::Toolkit::StyleManager *argp2 ;
61618
61619   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61620   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61621   if (!argp2) {
61622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61623     return ;
61624   }
61625   arg2 = *argp2;
61626   arg3 = (Dali::StyleChange::Type)jarg3;
61627   {
61628     try {
61629       (arg1)->OnStyleChange(arg2,arg3);
61630     } catch (std::out_of_range& e) {
61631       {
61632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61633       };
61634     } catch (std::exception& e) {
61635       {
61636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61637       };
61638     } catch (Dali::DaliException e) {
61639       {
61640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61641       };
61642     } catch (...) {
61643       {
61644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61645       };
61646     }
61647   }
61648
61649 }
61650
61651
61652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61653   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61654   Dali::Toolkit::StyleManager arg2 ;
61655   Dali::StyleChange::Type arg3 ;
61656   Dali::Toolkit::StyleManager *argp2 ;
61657
61658   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61659   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61660   if (!argp2) {
61661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61662     return ;
61663   }
61664   arg2 = *argp2;
61665   arg3 = (Dali::StyleChange::Type)jarg3;
61666   {
61667     try {
61668       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61669     } catch (std::out_of_range& e) {
61670       {
61671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61672       };
61673     } catch (std::exception& e) {
61674       {
61675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61676       };
61677     } catch (Dali::DaliException e) {
61678       {
61679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61680       };
61681     } catch (...) {
61682       {
61683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61684       };
61685     }
61686   }
61687
61688 }
61689
61690
61691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
61692   unsigned int jresult ;
61693   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61694   bool result;
61695
61696   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61697   {
61698     try {
61699       result = (bool)(arg1)->OnAccessibilityActivated();
61700     } catch (std::out_of_range& e) {
61701       {
61702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61703       };
61704     } catch (std::exception& e) {
61705       {
61706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61707       };
61708     } catch (Dali::DaliException e) {
61709       {
61710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61711       };
61712     } catch (...) {
61713       {
61714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61715       };
61716     }
61717   }
61718
61719   jresult = result;
61720   return jresult;
61721 }
61722
61723
61724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
61725   unsigned int jresult ;
61726   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61727   bool result;
61728
61729   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61730   {
61731     try {
61732       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
61733     } catch (std::out_of_range& e) {
61734       {
61735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61736       };
61737     } catch (std::exception& e) {
61738       {
61739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61740       };
61741     } catch (Dali::DaliException e) {
61742       {
61743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61744       };
61745     } catch (...) {
61746       {
61747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61748       };
61749     }
61750   }
61751
61752   jresult = result;
61753   return jresult;
61754 }
61755
61756
61757 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
61758   unsigned int jresult ;
61759   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61760   Dali::PanGesture arg2 ;
61761   Dali::PanGesture *argp2 ;
61762   bool result;
61763
61764   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61765   argp2 = (Dali::PanGesture *)jarg2;
61766   if (!argp2) {
61767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61768     return 0;
61769   }
61770   arg2 = *argp2;
61771   {
61772     try {
61773       result = (bool)(arg1)->OnAccessibilityPan(arg2);
61774     } catch (std::out_of_range& e) {
61775       {
61776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61777       };
61778     } catch (std::exception& e) {
61779       {
61780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61781       };
61782     } catch (Dali::DaliException e) {
61783       {
61784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61785       };
61786     } catch (...) {
61787       {
61788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61789       };
61790     }
61791   }
61792
61793   jresult = result;
61794   return jresult;
61795 }
61796
61797
61798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61799   unsigned int jresult ;
61800   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61801   Dali::PanGesture arg2 ;
61802   Dali::PanGesture *argp2 ;
61803   bool result;
61804
61805   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61806   argp2 = (Dali::PanGesture *)jarg2;
61807   if (!argp2) {
61808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61809     return 0;
61810   }
61811   arg2 = *argp2;
61812   {
61813     try {
61814       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
61815     } catch (std::out_of_range& e) {
61816       {
61817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61818       };
61819     } catch (std::exception& e) {
61820       {
61821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61822       };
61823     } catch (Dali::DaliException e) {
61824       {
61825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61826       };
61827     } catch (...) {
61828       {
61829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61830       };
61831     }
61832   }
61833
61834   jresult = result;
61835   return jresult;
61836 }
61837
61838
61839
61840
61841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
61842   unsigned int jresult ;
61843   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61844   bool arg2 ;
61845   bool result;
61846
61847   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61848   arg2 = jarg2 ? true : false;
61849   {
61850     try {
61851       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
61852     } catch (std::out_of_range& e) {
61853       {
61854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61855       };
61856     } catch (std::exception& e) {
61857       {
61858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61859       };
61860     } catch (Dali::DaliException e) {
61861       {
61862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61863       };
61864     } catch (...) {
61865       {
61866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61867       };
61868     }
61869   }
61870
61871   jresult = result;
61872   return jresult;
61873 }
61874
61875
61876 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
61877   unsigned int jresult ;
61878   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61879   bool arg2 ;
61880   bool result;
61881
61882   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61883   arg2 = jarg2 ? true : false;
61884   {
61885     try {
61886       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
61887     } catch (std::out_of_range& e) {
61888       {
61889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61890       };
61891     } catch (std::exception& e) {
61892       {
61893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61894       };
61895     } catch (Dali::DaliException e) {
61896       {
61897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61898       };
61899     } catch (...) {
61900       {
61901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61902       };
61903     }
61904   }
61905
61906   jresult = result;
61907   return jresult;
61908 }
61909
61910
61911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
61912   unsigned int jresult ;
61913   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61914   bool result;
61915
61916   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61917   {
61918     try {
61919       result = (bool)(arg1)->OnAccessibilityZoom();
61920     } catch (std::out_of_range& e) {
61921       {
61922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61923       };
61924     } catch (std::exception& e) {
61925       {
61926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61927       };
61928     } catch (Dali::DaliException e) {
61929       {
61930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61931       };
61932     } catch (...) {
61933       {
61934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61935       };
61936     }
61937   }
61938
61939   jresult = result;
61940   return jresult;
61941 }
61942
61943
61944 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
61945   unsigned int jresult ;
61946   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61947   bool result;
61948
61949   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61950   {
61951     try {
61952       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
61953     } catch (std::out_of_range& e) {
61954       {
61955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61956       };
61957     } catch (std::exception& e) {
61958       {
61959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61960       };
61961     } catch (Dali::DaliException e) {
61962       {
61963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61964       };
61965     } catch (...) {
61966       {
61967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61968       };
61969     }
61970   }
61971
61972   jresult = result;
61973   return jresult;
61974 }
61975
61976
61977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
61978   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61979
61980   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61981   {
61982     try {
61983       (arg1)->OnKeyInputFocusGained();
61984     } catch (std::out_of_range& e) {
61985       {
61986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61987       };
61988     } catch (std::exception& e) {
61989       {
61990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61991       };
61992     } catch (Dali::DaliException e) {
61993       {
61994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61995       };
61996     } catch (...) {
61997       {
61998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61999       };
62000     }
62001   }
62002
62003 }
62004
62005
62006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62007   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62008
62009   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62010   {
62011     try {
62012       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62013     } catch (std::out_of_range& e) {
62014       {
62015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62016       };
62017     } catch (std::exception& e) {
62018       {
62019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62020       };
62021     } catch (Dali::DaliException e) {
62022       {
62023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62024       };
62025     } catch (...) {
62026       {
62027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62028       };
62029     }
62030   }
62031
62032 }
62033
62034
62035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62036   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62037
62038   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62039   {
62040     try {
62041       (arg1)->OnKeyInputFocusLost();
62042     } catch (std::out_of_range& e) {
62043       {
62044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62045       };
62046     } catch (std::exception& e) {
62047       {
62048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62049       };
62050     } catch (Dali::DaliException e) {
62051       {
62052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62053       };
62054     } catch (...) {
62055       {
62056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62057       };
62058     }
62059   }
62060
62061 }
62062
62063
62064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62065   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62066
62067   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62068   {
62069     try {
62070       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62071     } catch (std::out_of_range& e) {
62072       {
62073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62074       };
62075     } catch (std::exception& e) {
62076       {
62077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62078       };
62079     } catch (Dali::DaliException e) {
62080       {
62081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62082       };
62083     } catch (...) {
62084       {
62085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62086       };
62087     }
62088   }
62089
62090 }
62091
62092
62093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62094   void * jresult ;
62095   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62096   Dali::Actor arg2 ;
62097   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62098   bool arg4 ;
62099   Dali::Actor *argp2 ;
62100   Dali::Actor result;
62101
62102   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62103   argp2 = (Dali::Actor *)jarg2;
62104   if (!argp2) {
62105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62106     return 0;
62107   }
62108   arg2 = *argp2;
62109   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62110   arg4 = jarg4 ? true : false;
62111   {
62112     try {
62113       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62114     } catch (std::out_of_range& e) {
62115       {
62116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62117       };
62118     } catch (std::exception& e) {
62119       {
62120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62121       };
62122     } catch (Dali::DaliException e) {
62123       {
62124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62125       };
62126     } catch (...) {
62127       {
62128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62129       };
62130     }
62131   }
62132
62133   jresult = new Dali::Actor((const Dali::Actor &)result);
62134   return jresult;
62135 }
62136
62137
62138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62139   void * jresult ;
62140   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62141   Dali::Actor arg2 ;
62142   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62143   bool arg4 ;
62144   Dali::Actor *argp2 ;
62145   Dali::Actor result;
62146
62147   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62148   argp2 = (Dali::Actor *)jarg2;
62149   if (!argp2) {
62150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62151     return 0;
62152   }
62153   arg2 = *argp2;
62154   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62155   arg4 = jarg4 ? true : false;
62156   {
62157     try {
62158       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62159     } catch (std::out_of_range& e) {
62160       {
62161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62162       };
62163     } catch (std::exception& e) {
62164       {
62165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62166       };
62167     } catch (Dali::DaliException e) {
62168       {
62169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62170       };
62171     } catch (...) {
62172       {
62173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62174       };
62175     }
62176   }
62177
62178   jresult = new Dali::Actor((const Dali::Actor &)result);
62179   return jresult;
62180 }
62181
62182
62183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62184   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62185   Dali::Actor arg2 ;
62186   Dali::Actor *argp2 ;
62187
62188   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62189   argp2 = (Dali::Actor *)jarg2;
62190   if (!argp2) {
62191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62192     return ;
62193   }
62194   arg2 = *argp2;
62195   {
62196     try {
62197       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62198     } catch (std::out_of_range& e) {
62199       {
62200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62201       };
62202     } catch (std::exception& e) {
62203       {
62204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62205       };
62206     } catch (Dali::DaliException e) {
62207       {
62208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62209       };
62210     } catch (...) {
62211       {
62212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62213       };
62214     }
62215   }
62216
62217 }
62218
62219
62220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62221   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62222   Dali::Actor arg2 ;
62223   Dali::Actor *argp2 ;
62224
62225   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62226   argp2 = (Dali::Actor *)jarg2;
62227   if (!argp2) {
62228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62229     return ;
62230   }
62231   arg2 = *argp2;
62232   {
62233     try {
62234       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62235     } catch (std::out_of_range& e) {
62236       {
62237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62238       };
62239     } catch (std::exception& e) {
62240       {
62241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62242       };
62243     } catch (Dali::DaliException e) {
62244       {
62245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62246       };
62247     } catch (...) {
62248       {
62249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62250       };
62251     }
62252   }
62253
62254 }
62255
62256
62257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62258   unsigned int jresult ;
62259   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62260   bool result;
62261
62262   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62263   {
62264     try {
62265       result = (bool)(arg1)->OnKeyboardEnter();
62266     } catch (std::out_of_range& e) {
62267       {
62268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62269       };
62270     } catch (std::exception& e) {
62271       {
62272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62273       };
62274     } catch (Dali::DaliException e) {
62275       {
62276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62277       };
62278     } catch (...) {
62279       {
62280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62281       };
62282     }
62283   }
62284
62285   jresult = result;
62286   return jresult;
62287 }
62288
62289
62290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62291   unsigned int jresult ;
62292   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62293   bool result;
62294
62295   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62296   {
62297     try {
62298       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62299     } catch (std::out_of_range& e) {
62300       {
62301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62302       };
62303     } catch (std::exception& e) {
62304       {
62305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62306       };
62307     } catch (Dali::DaliException e) {
62308       {
62309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62310       };
62311     } catch (...) {
62312       {
62313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62314       };
62315     }
62316   }
62317
62318   jresult = result;
62319   return jresult;
62320 }
62321
62322
62323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62324   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62325   Dali::PinchGesture *arg2 = 0 ;
62326
62327   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62328   arg2 = (Dali::PinchGesture *)jarg2;
62329   if (!arg2) {
62330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62331     return ;
62332   }
62333   {
62334     try {
62335       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62336     } catch (std::out_of_range& e) {
62337       {
62338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62339       };
62340     } catch (std::exception& e) {
62341       {
62342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62343       };
62344     } catch (Dali::DaliException e) {
62345       {
62346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62347       };
62348     } catch (...) {
62349       {
62350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62351       };
62352     }
62353   }
62354
62355 }
62356
62357
62358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62359   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62360   Dali::PinchGesture *arg2 = 0 ;
62361
62362   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62363   arg2 = (Dali::PinchGesture *)jarg2;
62364   if (!arg2) {
62365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62366     return ;
62367   }
62368   {
62369     try {
62370       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62371     } catch (std::out_of_range& e) {
62372       {
62373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62374       };
62375     } catch (std::exception& e) {
62376       {
62377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62378       };
62379     } catch (Dali::DaliException e) {
62380       {
62381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62382       };
62383     } catch (...) {
62384       {
62385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62386       };
62387     }
62388   }
62389
62390 }
62391
62392
62393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62394   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62395   Dali::PanGesture *arg2 = 0 ;
62396
62397   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62398   arg2 = (Dali::PanGesture *)jarg2;
62399   if (!arg2) {
62400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62401     return ;
62402   }
62403   {
62404     try {
62405       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62406     } catch (std::out_of_range& e) {
62407       {
62408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62409       };
62410     } catch (std::exception& e) {
62411       {
62412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62413       };
62414     } catch (Dali::DaliException e) {
62415       {
62416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62417       };
62418     } catch (...) {
62419       {
62420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62421       };
62422     }
62423   }
62424
62425 }
62426
62427
62428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62429   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62430   Dali::PanGesture *arg2 = 0 ;
62431
62432   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62433   arg2 = (Dali::PanGesture *)jarg2;
62434   if (!arg2) {
62435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62436     return ;
62437   }
62438   {
62439     try {
62440       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62441     } catch (std::out_of_range& e) {
62442       {
62443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62444       };
62445     } catch (std::exception& e) {
62446       {
62447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62448       };
62449     } catch (Dali::DaliException e) {
62450       {
62451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62452       };
62453     } catch (...) {
62454       {
62455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62456       };
62457     }
62458   }
62459
62460 }
62461
62462
62463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62464   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62465   Dali::TapGesture *arg2 = 0 ;
62466
62467   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62468   arg2 = (Dali::TapGesture *)jarg2;
62469   if (!arg2) {
62470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62471     return ;
62472   }
62473   {
62474     try {
62475       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62476     } catch (std::out_of_range& e) {
62477       {
62478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62479       };
62480     } catch (std::exception& e) {
62481       {
62482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62483       };
62484     } catch (Dali::DaliException e) {
62485       {
62486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62487       };
62488     } catch (...) {
62489       {
62490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62491       };
62492     }
62493   }
62494
62495 }
62496
62497
62498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62499   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62500   Dali::TapGesture *arg2 = 0 ;
62501
62502   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62503   arg2 = (Dali::TapGesture *)jarg2;
62504   if (!arg2) {
62505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62506     return ;
62507   }
62508   {
62509     try {
62510       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
62511     } catch (std::out_of_range& e) {
62512       {
62513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62514       };
62515     } catch (std::exception& e) {
62516       {
62517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62518       };
62519     } catch (Dali::DaliException e) {
62520       {
62521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62522       };
62523     } catch (...) {
62524       {
62525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62526       };
62527     }
62528   }
62529
62530 }
62531
62532
62533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62534   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62535   Dali::LongPressGesture *arg2 = 0 ;
62536
62537   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62538   arg2 = (Dali::LongPressGesture *)jarg2;
62539   if (!arg2) {
62540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62541     return ;
62542   }
62543   {
62544     try {
62545       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62546     } catch (std::out_of_range& e) {
62547       {
62548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62549       };
62550     } catch (std::exception& e) {
62551       {
62552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62553       };
62554     } catch (Dali::DaliException e) {
62555       {
62556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62557       };
62558     } catch (...) {
62559       {
62560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62561       };
62562     }
62563   }
62564
62565 }
62566
62567
62568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62569   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62570   Dali::LongPressGesture *arg2 = 0 ;
62571
62572   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62573   arg2 = (Dali::LongPressGesture *)jarg2;
62574   if (!arg2) {
62575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62576     return ;
62577   }
62578   {
62579     try {
62580       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62581     } catch (std::out_of_range& e) {
62582       {
62583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62584       };
62585     } catch (std::exception& e) {
62586       {
62587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62588       };
62589     } catch (Dali::DaliException e) {
62590       {
62591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62592       };
62593     } catch (...) {
62594       {
62595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62596       };
62597     }
62598   }
62599
62600 }
62601
62602
62603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62604   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62605   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62606   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62607
62608   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62609   arg2 = (Dali::SlotObserver *)jarg2;
62610   arg3 = (Dali::CallbackBase *)jarg3;
62611   {
62612     try {
62613       (arg1)->SignalConnected(arg2,arg3);
62614     } catch (std::out_of_range& e) {
62615       {
62616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62617       };
62618     } catch (std::exception& e) {
62619       {
62620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62621       };
62622     } catch (Dali::DaliException e) {
62623       {
62624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62625       };
62626     } catch (...) {
62627       {
62628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62629       };
62630     }
62631   }
62632
62633 }
62634
62635
62636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62637   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62638   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62639   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62640
62641   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62642   arg2 = (Dali::SlotObserver *)jarg2;
62643   arg3 = (Dali::CallbackBase *)jarg3;
62644   {
62645     try {
62646       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62647     } catch (std::out_of_range& e) {
62648       {
62649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62650       };
62651     } catch (std::exception& e) {
62652       {
62653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62654       };
62655     } catch (Dali::DaliException e) {
62656       {
62657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62658       };
62659     } catch (...) {
62660       {
62661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62662       };
62663     }
62664   }
62665
62666 }
62667
62668
62669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62670   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62671   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62672   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62673
62674   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62675   arg2 = (Dali::SlotObserver *)jarg2;
62676   arg3 = (Dali::CallbackBase *)jarg3;
62677   {
62678     try {
62679       (arg1)->SignalDisconnected(arg2,arg3);
62680     } catch (std::out_of_range& e) {
62681       {
62682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62683       };
62684     } catch (std::exception& e) {
62685       {
62686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62687       };
62688     } catch (Dali::DaliException e) {
62689       {
62690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62691       };
62692     } catch (...) {
62693       {
62694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62695       };
62696     }
62697   }
62698
62699 }
62700
62701
62702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62703   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62704   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62705   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62706
62707   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62708   arg2 = (Dali::SlotObserver *)jarg2;
62709   arg3 = (Dali::CallbackBase *)jarg3;
62710   {
62711     try {
62712       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62713     } catch (std::out_of_range& e) {
62714       {
62715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62716       };
62717     } catch (std::exception& e) {
62718       {
62719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62720       };
62721     } catch (Dali::DaliException e) {
62722       {
62723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62724       };
62725     } catch (...) {
62726       {
62727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62728       };
62729     }
62730   }
62731
62732 }
62733
62734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_director_connect(void *objarg, SwigDirector_ViewImpl::SWIG_Callback0_t callback0, SwigDirector_ViewImpl::SWIG_Callback1_t callback1, SwigDirector_ViewImpl::SWIG_Callback2_t callback2, SwigDirector_ViewImpl::SWIG_Callback3_t callback3, SwigDirector_ViewImpl::SWIG_Callback4_t callback4, SwigDirector_ViewImpl::SWIG_Callback5_t callback5, SwigDirector_ViewImpl::SWIG_Callback6_t callback6, SwigDirector_ViewImpl::SWIG_Callback8_t callback8, SwigDirector_ViewImpl::SWIG_Callback9_t callback9, SwigDirector_ViewImpl::SWIG_Callback10_t callback10, SwigDirector_ViewImpl::SWIG_Callback11_t callback11, SwigDirector_ViewImpl::SWIG_Callback12_t callback12, SwigDirector_ViewImpl::SWIG_Callback13_t callback13, SwigDirector_ViewImpl::SWIG_Callback14_t callback14, SwigDirector_ViewImpl::SWIG_Callback15_t callback15, SwigDirector_ViewImpl::SWIG_Callback16_t callback16, SwigDirector_ViewImpl::SWIG_Callback17_t callback17, SwigDirector_ViewImpl::SWIG_Callback18_t callback18, SwigDirector_ViewImpl::SWIG_Callback19_t callback19, SwigDirector_ViewImpl::SWIG_Callback20_t callback20, SwigDirector_ViewImpl::SWIG_Callback21_t callback21, SwigDirector_ViewImpl::SWIG_Callback24_t callback24, SwigDirector_ViewImpl::SWIG_Callback25_t callback25, SwigDirector_ViewImpl::SWIG_Callback26_t callback26, SwigDirector_ViewImpl::SWIG_Callback28_t callback28, SwigDirector_ViewImpl::SWIG_Callback29_t callback29, SwigDirector_ViewImpl::SWIG_Callback30_t callback30, SwigDirector_ViewImpl::SWIG_Callback31_t callback31, SwigDirector_ViewImpl::SWIG_Callback32_t callback32, SwigDirector_ViewImpl::SWIG_Callback33_t callback33, SwigDirector_ViewImpl::SWIG_Callback34_t callback34, SwigDirector_ViewImpl::SWIG_Callback35_t callback35, SwigDirector_ViewImpl::SWIG_Callback36_t callback36, SwigDirector_ViewImpl::SWIG_Callback37_t callback37, SwigDirector_ViewImpl::SWIG_Callback38_t callback38, SwigDirector_ViewImpl::SWIG_Callback39_t callback39, SwigDirector_ViewImpl::SWIG_Callback40_t callback40) {
62735   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62736   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62737   if (director) {
62738     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback8, callback9, callback10, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback24, callback25, callback26, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40);
62739   }
62740 }
62741
62742
62743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
62744   void * jresult ;
62745   Dali::Toolkit::Control *arg1 = 0 ;
62746   Dali::Toolkit::Internal::Control *result = 0 ;
62747
62748   arg1 = (Dali::Toolkit::Control *)jarg1;
62749   if (!arg1) {
62750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62751     return 0;
62752   }
62753   {
62754     try {
62755       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62756     } catch (std::out_of_range& e) {
62757       {
62758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62759       };
62760     } catch (std::exception& e) {
62761       {
62762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62763       };
62764     } catch (Dali::DaliException e) {
62765       {
62766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62767       };
62768     } catch (...) {
62769       {
62770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62771       };
62772     }
62773   }
62774
62775   jresult = (void *)result;
62776   return jresult;
62777 }
62778
62779
62780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
62781   int jresult ;
62782   int result;
62783
62784   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
62785   jresult = (int)result;
62786   return jresult;
62787 }
62788
62789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
62790   int jresult ;
62791   int result;
62792
62793   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
62794   jresult = (int)result;
62795   return jresult;
62796 }
62797
62798
62799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
62800   int jresult ;
62801   int result;
62802
62803   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
62804   jresult = (int)result;
62805   return jresult;
62806 }
62807
62808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
62809   int jresult ;
62810   int result;
62811
62812   result = (int)Dali::Toolkit::Control::Property::MARGIN;
62813   jresult = (int)result;
62814   return jresult;
62815 }
62816
62817
62818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
62819   int jresult ;
62820   int result;
62821
62822   result = (int)Dali::Toolkit::Control::Property::PADDING;
62823   jresult = (int)result;
62824   return jresult;
62825 }
62826
62827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
62828   int jresult ;
62829   int result;
62830
62831   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
62832   jresult = (int)result;
62833   return jresult;
62834 }
62835
62836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
62837   void * jresult ;
62838   Dali::Toolkit::Control::Property *result = 0 ;
62839
62840   {
62841     try {
62842       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
62843     } catch (std::out_of_range& e) {
62844       {
62845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62846       };
62847     } catch (std::exception& e) {
62848       {
62849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62850       };
62851     } catch (Dali::DaliException e) {
62852       {
62853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62854       };
62855     } catch (...) {
62856       {
62857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62858       };
62859     }
62860   }
62861
62862   jresult = (void *)result;
62863   return jresult;
62864 }
62865
62866
62867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
62868   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
62869
62870   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
62871   {
62872     try {
62873       delete arg1;
62874     } catch (std::out_of_range& e) {
62875       {
62876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62877       };
62878     } catch (std::exception& e) {
62879       {
62880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62881       };
62882     } catch (Dali::DaliException e) {
62883       {
62884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62885       };
62886     } catch (...) {
62887       {
62888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62889       };
62890     }
62891   }
62892
62893 }
62894
62895
62896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
62897   void * jresult ;
62898   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
62899
62900   {
62901     try {
62902       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
62903     } catch (std::out_of_range& e) {
62904       {
62905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62906       };
62907     } catch (std::exception& e) {
62908       {
62909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62910       };
62911     } catch (Dali::DaliException e) {
62912       {
62913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62914       };
62915     } catch (...) {
62916       {
62917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62918       };
62919     }
62920   }
62921
62922   jresult = (void *)result;
62923   return jresult;
62924 }
62925
62926
62927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
62928   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
62929
62930   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
62931   {
62932     try {
62933       delete arg1;
62934     } catch (std::out_of_range& e) {
62935       {
62936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62937       };
62938     } catch (std::exception& e) {
62939       {
62940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62941       };
62942     } catch (Dali::DaliException e) {
62943       {
62944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62945       };
62946     } catch (...) {
62947       {
62948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62949       };
62950     }
62951   }
62952
62953 }
62954
62955
62956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
62957   void * jresult ;
62958   Dali::Toolkit::Control result;
62959
62960   {
62961     try {
62962       result = Dali::Toolkit::Control::New();
62963     } catch (std::out_of_range& e) {
62964       {
62965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62966       };
62967     } catch (std::exception& e) {
62968       {
62969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62970       };
62971     } catch (Dali::DaliException e) {
62972       {
62973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62974       };
62975     } catch (...) {
62976       {
62977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62978       };
62979     }
62980   }
62981
62982   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62983   return jresult;
62984 }
62985
62986
62987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
62988   void * jresult ;
62989   Dali::Toolkit::Control *result = 0 ;
62990
62991   {
62992     try {
62993       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
62994     } catch (std::out_of_range& e) {
62995       {
62996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62997       };
62998     } catch (std::exception& e) {
62999       {
63000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63001       };
63002     } catch (Dali::DaliException e) {
63003       {
63004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63005       };
63006     } catch (...) {
63007       {
63008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63009       };
63010     }
63011   }
63012
63013   jresult = (void *)result;
63014   return jresult;
63015 }
63016
63017
63018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63019   void * jresult ;
63020   Dali::Toolkit::Control *arg1 = 0 ;
63021   Dali::Toolkit::Control *result = 0 ;
63022
63023   arg1 = (Dali::Toolkit::Control *)jarg1;
63024   if (!arg1) {
63025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63026     return 0;
63027   }
63028   {
63029     try {
63030       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63031     } catch (std::out_of_range& e) {
63032       {
63033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63034       };
63035     } catch (std::exception& e) {
63036       {
63037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63038       };
63039     } catch (Dali::DaliException e) {
63040       {
63041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63042       };
63043     } catch (...) {
63044       {
63045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63046       };
63047     }
63048   }
63049
63050   jresult = (void *)result;
63051   return jresult;
63052 }
63053
63054
63055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63056   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63057
63058   arg1 = (Dali::Toolkit::Control *)jarg1;
63059   {
63060     try {
63061       delete arg1;
63062     } catch (std::out_of_range& e) {
63063       {
63064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63065       };
63066     } catch (std::exception& e) {
63067       {
63068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63069       };
63070     } catch (Dali::DaliException e) {
63071       {
63072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63073       };
63074     } catch (...) {
63075       {
63076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63077       };
63078     }
63079   }
63080
63081 }
63082
63083
63084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63085   void * jresult ;
63086   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63087   Dali::Toolkit::Control *arg2 = 0 ;
63088   Dali::Toolkit::Control *result = 0 ;
63089
63090   arg1 = (Dali::Toolkit::Control *)jarg1;
63091   arg2 = (Dali::Toolkit::Control *)jarg2;
63092   if (!arg2) {
63093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63094     return 0;
63095   }
63096   {
63097     try {
63098       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63099     } catch (std::out_of_range& e) {
63100       {
63101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63102       };
63103     } catch (std::exception& e) {
63104       {
63105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63106       };
63107     } catch (Dali::DaliException e) {
63108       {
63109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63110       };
63111     } catch (...) {
63112       {
63113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63114       };
63115     }
63116   }
63117
63118   jresult = (void *)result;
63119   return jresult;
63120 }
63121
63122
63123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63124   void * jresult ;
63125   Dali::BaseHandle arg1 ;
63126   Dali::BaseHandle *argp1 ;
63127   Dali::Toolkit::Control result;
63128
63129   argp1 = (Dali::BaseHandle *)jarg1;
63130   if (!argp1) {
63131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63132     return 0;
63133   }
63134   arg1 = *argp1;
63135   {
63136     try {
63137       result = Dali::Toolkit::Control::DownCast(arg1);
63138     } catch (std::out_of_range& e) {
63139       {
63140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63141       };
63142     } catch (std::exception& e) {
63143       {
63144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63145       };
63146     } catch (Dali::DaliException e) {
63147       {
63148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63149       };
63150     } catch (...) {
63151       {
63152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63153       };
63154     }
63155   }
63156
63157   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63158   return jresult;
63159 }
63160
63161
63162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63163   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63164
63165   arg1 = (Dali::Toolkit::Control *)jarg1;
63166   {
63167     try {
63168       (arg1)->SetKeyInputFocus();
63169     } catch (std::out_of_range& e) {
63170       {
63171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63172       };
63173     } catch (std::exception& e) {
63174       {
63175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63176       };
63177     } catch (Dali::DaliException e) {
63178       {
63179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63180       };
63181     } catch (...) {
63182       {
63183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63184       };
63185     }
63186   }
63187
63188 }
63189
63190
63191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63192   unsigned int jresult ;
63193   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63194   bool result;
63195
63196   arg1 = (Dali::Toolkit::Control *)jarg1;
63197   {
63198     try {
63199       result = (bool)(arg1)->HasKeyInputFocus();
63200     } catch (std::out_of_range& e) {
63201       {
63202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63203       };
63204     } catch (std::exception& e) {
63205       {
63206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63207       };
63208     } catch (Dali::DaliException e) {
63209       {
63210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63211       };
63212     } catch (...) {
63213       {
63214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63215       };
63216     }
63217   }
63218
63219   jresult = result;
63220   return jresult;
63221 }
63222
63223
63224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63225   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63226
63227   arg1 = (Dali::Toolkit::Control *)jarg1;
63228   {
63229     try {
63230       (arg1)->ClearKeyInputFocus();
63231     } catch (std::out_of_range& e) {
63232       {
63233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63234       };
63235     } catch (std::exception& e) {
63236       {
63237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63238       };
63239     } catch (Dali::DaliException e) {
63240       {
63241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63242       };
63243     } catch (...) {
63244       {
63245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63246       };
63247     }
63248   }
63249
63250 }
63251
63252
63253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63254   void * jresult ;
63255   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63256   Dali::PinchGestureDetector result;
63257
63258   arg1 = (Dali::Toolkit::Control *)jarg1;
63259   {
63260     try {
63261       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63262     } catch (std::out_of_range& e) {
63263       {
63264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63265       };
63266     } catch (std::exception& e) {
63267       {
63268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63269       };
63270     } catch (Dali::DaliException e) {
63271       {
63272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63273       };
63274     } catch (...) {
63275       {
63276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63277       };
63278     }
63279   }
63280
63281   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63282   return jresult;
63283 }
63284
63285
63286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63287   void * jresult ;
63288   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63289   Dali::PanGestureDetector result;
63290
63291   arg1 = (Dali::Toolkit::Control *)jarg1;
63292   {
63293     try {
63294       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63295     } catch (std::out_of_range& e) {
63296       {
63297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63298       };
63299     } catch (std::exception& e) {
63300       {
63301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63302       };
63303     } catch (Dali::DaliException e) {
63304       {
63305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63306       };
63307     } catch (...) {
63308       {
63309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63310       };
63311     }
63312   }
63313
63314   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63315   return jresult;
63316 }
63317
63318
63319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63320   void * jresult ;
63321   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63322   Dali::TapGestureDetector result;
63323
63324   arg1 = (Dali::Toolkit::Control *)jarg1;
63325   {
63326     try {
63327       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63328     } catch (std::out_of_range& e) {
63329       {
63330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63331       };
63332     } catch (std::exception& e) {
63333       {
63334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63335       };
63336     } catch (Dali::DaliException e) {
63337       {
63338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63339       };
63340     } catch (...) {
63341       {
63342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63343       };
63344     }
63345   }
63346
63347   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63348   return jresult;
63349 }
63350
63351
63352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63353   void * jresult ;
63354   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63355   Dali::LongPressGestureDetector result;
63356
63357   arg1 = (Dali::Toolkit::Control *)jarg1;
63358   {
63359     try {
63360       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63361     } catch (std::out_of_range& e) {
63362       {
63363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63364       };
63365     } catch (std::exception& e) {
63366       {
63367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63368       };
63369     } catch (Dali::DaliException e) {
63370       {
63371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63372       };
63373     } catch (...) {
63374       {
63375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63376       };
63377     }
63378   }
63379
63380   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63381   return jresult;
63382 }
63383
63384
63385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63386   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63387   std::string *arg2 = 0 ;
63388
63389   arg1 = (Dali::Toolkit::Control *)jarg1;
63390   if (!jarg2) {
63391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63392     return ;
63393   }
63394   std::string arg2_str(jarg2);
63395   arg2 = &arg2_str;
63396   {
63397     try {
63398       (arg1)->SetStyleName((std::string const &)*arg2);
63399     } catch (std::out_of_range& e) {
63400       {
63401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63402       };
63403     } catch (std::exception& e) {
63404       {
63405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63406       };
63407     } catch (Dali::DaliException e) {
63408       {
63409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63410       };
63411     } catch (...) {
63412       {
63413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63414       };
63415     }
63416   }
63417
63418
63419   //argout typemap for const std::string&
63420
63421 }
63422
63423
63424 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63425   char * jresult ;
63426   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63427   std::string *result = 0 ;
63428
63429   arg1 = (Dali::Toolkit::Control *)jarg1;
63430   {
63431     try {
63432       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63433     } catch (std::out_of_range& e) {
63434       {
63435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63436       };
63437     } catch (std::exception& e) {
63438       {
63439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63440       };
63441     } catch (Dali::DaliException e) {
63442       {
63443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63444       };
63445     } catch (...) {
63446       {
63447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63448       };
63449     }
63450   }
63451
63452   jresult = SWIG_csharp_string_callback(result->c_str());
63453   return jresult;
63454 }
63455
63456
63457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63458   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63459   Dali::Vector4 *arg2 = 0 ;
63460
63461   arg1 = (Dali::Toolkit::Control *)jarg1;
63462   arg2 = (Dali::Vector4 *)jarg2;
63463   if (!arg2) {
63464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63465     return ;
63466   }
63467   {
63468     try {
63469       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63470     } catch (std::out_of_range& e) {
63471       {
63472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63473       };
63474     } catch (std::exception& e) {
63475       {
63476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63477       };
63478     } catch (Dali::DaliException e) {
63479       {
63480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63481       };
63482     } catch (...) {
63483       {
63484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63485       };
63486     }
63487   }
63488
63489 }
63490
63491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
63492   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63493
63494   arg1 = (Dali::Toolkit::Control *)jarg1;
63495   {
63496     try {
63497       (arg1)->ClearBackground();
63498     } catch (std::out_of_range& e) {
63499       {
63500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63501       };
63502     } catch (std::exception& e) {
63503       {
63504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63505       };
63506     } catch (Dali::DaliException e) {
63507       {
63508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63509       };
63510     } catch (...) {
63511       {
63512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63513       };
63514     }
63515   }
63516
63517 }
63518
63519
63520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
63521   void * jresult ;
63522   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63523   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63524
63525   arg1 = (Dali::Toolkit::Control *)jarg1;
63526   {
63527     try {
63528       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63529     } catch (std::out_of_range& e) {
63530       {
63531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63532       };
63533     } catch (std::exception& e) {
63534       {
63535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63536       };
63537     } catch (Dali::DaliException e) {
63538       {
63539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63540       };
63541     } catch (...) {
63542       {
63543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63544       };
63545     }
63546   }
63547
63548   jresult = (void *)result;
63549   return jresult;
63550 }
63551
63552
63553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
63554   void * jresult ;
63555   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63556   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63557
63558   arg1 = (Dali::Toolkit::Control *)jarg1;
63559   {
63560     try {
63561       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63562     } catch (std::out_of_range& e) {
63563       {
63564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63565       };
63566     } catch (std::exception& e) {
63567       {
63568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63569       };
63570     } catch (Dali::DaliException e) {
63571       {
63572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63573       };
63574     } catch (...) {
63575       {
63576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63577       };
63578     }
63579   }
63580
63581   jresult = (void *)result;
63582   return jresult;
63583 }
63584
63585
63586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
63587   void * jresult ;
63588   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63589   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63590
63591   arg1 = (Dali::Toolkit::Control *)jarg1;
63592   {
63593     try {
63594       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63595     } catch (std::out_of_range& e) {
63596       {
63597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63598       };
63599     } catch (std::exception& e) {
63600       {
63601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63602       };
63603     } catch (Dali::DaliException e) {
63604       {
63605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63606       };
63607     } catch (...) {
63608       {
63609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63610       };
63611     }
63612   }
63613
63614   jresult = (void *)result;
63615   return jresult;
63616 }
63617
63618
63619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
63620   void * jresult ;
63621   Dali::Toolkit::Internal::Control *arg1 = 0 ;
63622   Dali::Toolkit::Control *result = 0 ;
63623
63624   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63625   if (!arg1) {
63626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63627     return 0;
63628   }
63629   {
63630     try {
63631       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63632     } catch (std::out_of_range& e) {
63633       {
63634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63635       };
63636     } catch (std::exception& e) {
63637       {
63638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63639       };
63640     } catch (Dali::DaliException e) {
63641       {
63642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63643       };
63644     } catch (...) {
63645       {
63646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63647       };
63648     }
63649   }
63650
63651   jresult = (void *)result;
63652   return jresult;
63653 }
63654
63655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
63656 {
63657   int jresult;
63658   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63659   arg1 = (Dali::Toolkit::Control *)jarg1;
63660
63661   if (!arg1) {
63662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63663     return 0;
63664   }
63665
63666   Dali::Property::Index arg2 = 0 ;
63667   arg2 = (Dali::Property::Index)jarg2;
63668
63669   Toolkit::Visual::ResourceStatus result;
63670   {
63671     try {
63672       result = arg1->GetVisualResourceStatus(arg2);
63673     } catch (std::out_of_range& e) {
63674       {
63675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63676       };
63677     } catch (std::exception& e) {
63678       {
63679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63680       };
63681     } catch (...) {
63682       {
63683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63684       };
63685     }
63686   }
63687   jresult = (int)(result);
63688   return jresult;
63689 }
63690
63691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
63692 {
63693   void * jresult;
63694   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63695   arg1 = (Dali::Toolkit::Control *)jarg1;
63696
63697   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
63698
63699   Dali::Toolkit::TransitionData *arg2 = 0 ;
63700   Dali::Animation result;
63701
63702   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
63703   if (!arg2) {
63704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
63705     return 0;
63706   }
63707   {
63708     try {
63709       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
63710     } catch (std::out_of_range& e) {
63711       {
63712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63713       };
63714     } catch (std::exception& e) {
63715       {
63716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63717       };
63718     } catch (Dali::DaliException e) {
63719       {
63720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63721       };
63722     } catch (...) {
63723       {
63724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63725       };
63726     }
63727   }
63728
63729   jresult = new Dali::Animation((const Dali::Animation &)result);
63730   return jresult;
63731 }
63732
63733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
63734 {
63735   Dali::Toolkit::Control arg1;
63736   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
63737
63738   if (!argp1) {
63739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63740   }
63741   arg1 = *argp1;
63742
63743   Dali::Property::Index arg2 = 0 ;
63744   arg2 = (Dali::Property::Index)jarg2;
63745
63746   Dali::Property::Index arg3 = 0 ;
63747   arg3 = (Dali::Property::Index)jarg3;
63748
63749   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
63750
63751   {
63752     try {
63753       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
63754     } catch (std::out_of_range& e) {
63755       {
63756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63757       };
63758     } catch (std::exception& e) {
63759       {
63760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63761       };
63762     } catch (...) {
63763       {
63764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63765       };
63766     }
63767   }
63768
63769
63770 }
63771
63772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
63773   void * jresult ;
63774   Dali::Toolkit::Control *arg1 = 0 ;
63775   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
63776
63777   arg1 = (Dali::Toolkit::Control *)jarg1;
63778   if (!arg1) {
63779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63780     return 0;
63781   }
63782   {
63783     try {
63784       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
63785     } catch (std::out_of_range& e) {
63786       {
63787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63788       };
63789     } catch (std::exception& e) {
63790       {
63791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63792       };
63793     } catch (Dali::DaliException e) {
63794       {
63795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63796       };
63797     } catch (...) {
63798       {
63799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63800       };
63801     }
63802   }
63803
63804   jresult = (void *)result;
63805   return jresult;
63806 }
63807
63808
63809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
63810   unsigned int jresult ;
63811   Dali::Toolkit::Control *arg1 = 0 ;
63812   bool result;
63813
63814   arg1 = (Dali::Toolkit::Control *)jarg1;
63815   if (!arg1) {
63816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63817     return 0;
63818   }
63819   {
63820     try {
63821       result = (bool)arg1->IsResourceReady();
63822     } catch (std::out_of_range& e) {
63823       {
63824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63825       };
63826     } catch (std::exception& e) {
63827       {
63828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63829       };
63830     } catch (Dali::DaliException e) {
63831       {
63832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63833       };
63834     } catch (...) {
63835       {
63836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63837       };
63838     }
63839   }
63840
63841   jresult = result;
63842   return jresult;
63843 }
63844
63845
63846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
63847   void * jresult ;
63848   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
63849
63850   {
63851     try {
63852       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
63853     } catch (std::out_of_range& e) {
63854       {
63855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63856       };
63857     } catch (std::exception& e) {
63858       {
63859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63860       };
63861     } catch (Dali::DaliException e) {
63862       {
63863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63864       };
63865     } catch (...) {
63866       {
63867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63868       };
63869     }
63870   }
63871
63872   jresult = (void *)result;
63873   return jresult;
63874 }
63875
63876
63877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
63878   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63879
63880   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63881   {
63882     try {
63883       delete arg1;
63884     } catch (std::out_of_range& e) {
63885       {
63886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63887       };
63888     } catch (std::exception& e) {
63889       {
63890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63891       };
63892     } catch (Dali::DaliException e) {
63893       {
63894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63895       };
63896     } catch (...) {
63897       {
63898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63899       };
63900     }
63901   }
63902
63903 }
63904
63905
63906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
63907   void * jresult ;
63908   Dali::Toolkit::KeyInputFocusManager result;
63909
63910   {
63911     try {
63912       result = Dali::Toolkit::KeyInputFocusManager::Get();
63913     } catch (std::out_of_range& e) {
63914       {
63915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63916       };
63917     } catch (std::exception& e) {
63918       {
63919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63920       };
63921     } catch (Dali::DaliException e) {
63922       {
63923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63924       };
63925     } catch (...) {
63926       {
63927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63928       };
63929     }
63930   }
63931
63932   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
63933   return jresult;
63934 }
63935
63936
63937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
63938   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63939   Dali::Toolkit::Control arg2 ;
63940   Dali::Toolkit::Control *argp2 ;
63941
63942   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63943   argp2 = (Dali::Toolkit::Control *)jarg2;
63944   if (!argp2) {
63945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63946     return ;
63947   }
63948   arg2 = *argp2;
63949   {
63950     try {
63951       (arg1)->SetFocus(arg2);
63952     } catch (std::out_of_range& e) {
63953       {
63954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63955       };
63956     } catch (std::exception& e) {
63957       {
63958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63959       };
63960     } catch (Dali::DaliException e) {
63961       {
63962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63963       };
63964     } catch (...) {
63965       {
63966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63967       };
63968     }
63969   }
63970
63971 }
63972
63973
63974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
63975   void * jresult ;
63976   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63977   Dali::Toolkit::Control result;
63978
63979   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63980   {
63981     try {
63982       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
63983     } catch (std::out_of_range& e) {
63984       {
63985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63986       };
63987     } catch (std::exception& e) {
63988       {
63989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63990       };
63991     } catch (Dali::DaliException e) {
63992       {
63993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63994       };
63995     } catch (...) {
63996       {
63997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63998       };
63999     }
64000   }
64001
64002   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64003   return jresult;
64004 }
64005
64006
64007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64008   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64009   Dali::Toolkit::Control arg2 ;
64010   Dali::Toolkit::Control *argp2 ;
64011
64012   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64013   argp2 = (Dali::Toolkit::Control *)jarg2;
64014   if (!argp2) {
64015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64016     return ;
64017   }
64018   arg2 = *argp2;
64019   {
64020     try {
64021       (arg1)->RemoveFocus(arg2);
64022     } catch (std::out_of_range& e) {
64023       {
64024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64025       };
64026     } catch (std::exception& e) {
64027       {
64028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64029       };
64030     } catch (Dali::DaliException e) {
64031       {
64032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64033       };
64034     } catch (...) {
64035       {
64036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64037       };
64038     }
64039   }
64040
64041 }
64042
64043
64044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64045   void * jresult ;
64046   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64047   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64048
64049   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64050   {
64051     try {
64052       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64053     } catch (std::out_of_range& e) {
64054       {
64055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64056       };
64057     } catch (std::exception& e) {
64058       {
64059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64060       };
64061     } catch (Dali::DaliException e) {
64062       {
64063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64064       };
64065     } catch (...) {
64066       {
64067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64068       };
64069     }
64070   }
64071
64072   jresult = (void *)result;
64073   return jresult;
64074 }
64075
64076
64077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
64078   void * jresult ;
64079   Dali::Toolkit::Alignment::Padding *result = 0 ;
64080
64081   {
64082     try {
64083       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64084     } catch (std::out_of_range& e) {
64085       {
64086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64087       };
64088     } catch (std::exception& e) {
64089       {
64090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64091       };
64092     } catch (Dali::DaliException e) {
64093       {
64094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64095       };
64096     } catch (...) {
64097       {
64098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64099       };
64100     }
64101   }
64102
64103   jresult = (void *)result;
64104   return jresult;
64105 }
64106
64107
64108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64109   void * jresult ;
64110   float arg1 ;
64111   float arg2 ;
64112   float arg3 ;
64113   float arg4 ;
64114   Dali::Toolkit::Alignment::Padding *result = 0 ;
64115
64116   arg1 = (float)jarg1;
64117   arg2 = (float)jarg2;
64118   arg3 = (float)jarg3;
64119   arg4 = (float)jarg4;
64120   {
64121     try {
64122       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64123     } catch (std::out_of_range& e) {
64124       {
64125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64126       };
64127     } catch (std::exception& e) {
64128       {
64129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64130       };
64131     } catch (Dali::DaliException e) {
64132       {
64133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64134       };
64135     } catch (...) {
64136       {
64137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64138       };
64139     }
64140   }
64141
64142   jresult = (void *)result;
64143   return jresult;
64144 }
64145
64146
64147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64148   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64149   float arg2 ;
64150
64151   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64152   arg2 = (float)jarg2;
64153   if (arg1) (arg1)->left = arg2;
64154 }
64155
64156
64157 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
64158   float jresult ;
64159   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64160   float result;
64161
64162   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64163   result = (float) ((arg1)->left);
64164   jresult = result;
64165   return jresult;
64166 }
64167
64168
64169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64170   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64171   float arg2 ;
64172
64173   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64174   arg2 = (float)jarg2;
64175   if (arg1) (arg1)->right = arg2;
64176 }
64177
64178
64179 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
64180   float jresult ;
64181   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64182   float result;
64183
64184   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64185   result = (float) ((arg1)->right);
64186   jresult = result;
64187   return jresult;
64188 }
64189
64190
64191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64192   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64193   float arg2 ;
64194
64195   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64196   arg2 = (float)jarg2;
64197   if (arg1) (arg1)->top = arg2;
64198 }
64199
64200
64201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
64202   float jresult ;
64203   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64204   float result;
64205
64206   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64207   result = (float) ((arg1)->top);
64208   jresult = result;
64209   return jresult;
64210 }
64211
64212
64213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64214   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64215   float arg2 ;
64216
64217   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64218   arg2 = (float)jarg2;
64219   if (arg1) (arg1)->bottom = arg2;
64220 }
64221
64222
64223 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64224   float jresult ;
64225   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64226   float result;
64227
64228   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64229   result = (float) ((arg1)->bottom);
64230   jresult = result;
64231   return jresult;
64232 }
64233
64234
64235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64236   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64237
64238   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64239   {
64240     try {
64241       delete arg1;
64242     } catch (std::out_of_range& e) {
64243       {
64244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64245       };
64246     } catch (std::exception& e) {
64247       {
64248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64249       };
64250     } catch (Dali::DaliException e) {
64251       {
64252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64253       };
64254     } catch (...) {
64255       {
64256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64257       };
64258     }
64259   }
64260
64261 }
64262
64263
64264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64265   void * jresult ;
64266   Dali::Toolkit::Alignment *result = 0 ;
64267
64268   {
64269     try {
64270       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64271     } catch (std::out_of_range& e) {
64272       {
64273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64274       };
64275     } catch (std::exception& e) {
64276       {
64277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64278       };
64279     } catch (Dali::DaliException e) {
64280       {
64281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64282       };
64283     } catch (...) {
64284       {
64285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64286       };
64287     }
64288   }
64289
64290   jresult = (void *)result;
64291   return jresult;
64292 }
64293
64294
64295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64296   void * jresult ;
64297   Dali::Toolkit::Alignment::Type arg1 ;
64298   Dali::Toolkit::Alignment::Type arg2 ;
64299   Dali::Toolkit::Alignment result;
64300
64301   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64302   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64303   {
64304     try {
64305       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64306     } catch (std::out_of_range& e) {
64307       {
64308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64309       };
64310     } catch (std::exception& e) {
64311       {
64312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64313       };
64314     } catch (Dali::DaliException e) {
64315       {
64316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64317       };
64318     } catch (...) {
64319       {
64320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64321       };
64322     }
64323   }
64324
64325   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64326   return jresult;
64327 }
64328
64329
64330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64331   void * jresult ;
64332   Dali::Toolkit::Alignment::Type arg1 ;
64333   Dali::Toolkit::Alignment result;
64334
64335   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64336   {
64337     try {
64338       result = Dali::Toolkit::Alignment::New(arg1);
64339     } catch (std::out_of_range& e) {
64340       {
64341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64342       };
64343     } catch (std::exception& e) {
64344       {
64345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64346       };
64347     } catch (Dali::DaliException e) {
64348       {
64349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64350       };
64351     } catch (...) {
64352       {
64353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64354       };
64355     }
64356   }
64357
64358   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64359   return jresult;
64360 }
64361
64362
64363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64364   void * jresult ;
64365   Dali::Toolkit::Alignment result;
64366
64367   {
64368     try {
64369       result = Dali::Toolkit::Alignment::New();
64370     } catch (std::out_of_range& e) {
64371       {
64372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64373       };
64374     } catch (std::exception& e) {
64375       {
64376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64377       };
64378     } catch (Dali::DaliException e) {
64379       {
64380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64381       };
64382     } catch (...) {
64383       {
64384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64385       };
64386     }
64387   }
64388
64389   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64390   return jresult;
64391 }
64392
64393
64394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64395   void * jresult ;
64396   Dali::Toolkit::Alignment *arg1 = 0 ;
64397   Dali::Toolkit::Alignment *result = 0 ;
64398
64399   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64400   if (!arg1) {
64401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64402     return 0;
64403   }
64404   {
64405     try {
64406       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64407     } catch (std::out_of_range& e) {
64408       {
64409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64410       };
64411     } catch (std::exception& e) {
64412       {
64413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64414       };
64415     } catch (Dali::DaliException e) {
64416       {
64417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64418       };
64419     } catch (...) {
64420       {
64421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64422       };
64423     }
64424   }
64425
64426   jresult = (void *)result;
64427   return jresult;
64428 }
64429
64430
64431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64432   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64433
64434   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64435   {
64436     try {
64437       delete arg1;
64438     } catch (std::out_of_range& e) {
64439       {
64440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64441       };
64442     } catch (std::exception& e) {
64443       {
64444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64445       };
64446     } catch (Dali::DaliException e) {
64447       {
64448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64449       };
64450     } catch (...) {
64451       {
64452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64453       };
64454     }
64455   }
64456
64457 }
64458
64459
64460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64461   void * jresult ;
64462   Dali::BaseHandle arg1 ;
64463   Dali::BaseHandle *argp1 ;
64464   Dali::Toolkit::Alignment result;
64465
64466   argp1 = (Dali::BaseHandle *)jarg1;
64467   if (!argp1) {
64468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64469     return 0;
64470   }
64471   arg1 = *argp1;
64472   {
64473     try {
64474       result = Dali::Toolkit::Alignment::DownCast(arg1);
64475     } catch (std::out_of_range& e) {
64476       {
64477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64478       };
64479     } catch (std::exception& e) {
64480       {
64481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64482       };
64483     } catch (Dali::DaliException e) {
64484       {
64485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64486       };
64487     } catch (...) {
64488       {
64489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64490       };
64491     }
64492   }
64493
64494   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64495   return jresult;
64496 }
64497
64498
64499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64500   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64501   Dali::Toolkit::Alignment::Type arg2 ;
64502
64503   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64504   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64505   {
64506     try {
64507       (arg1)->SetAlignmentType(arg2);
64508     } catch (std::out_of_range& e) {
64509       {
64510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64511       };
64512     } catch (std::exception& e) {
64513       {
64514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64515       };
64516     } catch (Dali::DaliException e) {
64517       {
64518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64519       };
64520     } catch (...) {
64521       {
64522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64523       };
64524     }
64525   }
64526
64527 }
64528
64529
64530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64531   int jresult ;
64532   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64533   Dali::Toolkit::Alignment::Type result;
64534
64535   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64536   {
64537     try {
64538       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64539     } catch (std::out_of_range& e) {
64540       {
64541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64542       };
64543     } catch (std::exception& e) {
64544       {
64545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64546       };
64547     } catch (Dali::DaliException e) {
64548       {
64549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64550       };
64551     } catch (...) {
64552       {
64553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64554       };
64555     }
64556   }
64557
64558   jresult = (int)result;
64559   return jresult;
64560 }
64561
64562
64563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64564   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64565   Dali::Toolkit::Alignment::Scaling arg2 ;
64566
64567   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64568   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64569   {
64570     try {
64571       (arg1)->SetScaling(arg2);
64572     } catch (std::out_of_range& e) {
64573       {
64574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64575       };
64576     } catch (std::exception& e) {
64577       {
64578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64579       };
64580     } catch (Dali::DaliException e) {
64581       {
64582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64583       };
64584     } catch (...) {
64585       {
64586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64587       };
64588     }
64589   }
64590
64591 }
64592
64593
64594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64595   int jresult ;
64596   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64597   Dali::Toolkit::Alignment::Scaling result;
64598
64599   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64600   {
64601     try {
64602       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64603     } catch (std::out_of_range& e) {
64604       {
64605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64606       };
64607     } catch (std::exception& e) {
64608       {
64609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64610       };
64611     } catch (Dali::DaliException e) {
64612       {
64613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64614       };
64615     } catch (...) {
64616       {
64617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64618       };
64619     }
64620   }
64621
64622   jresult = (int)result;
64623   return jresult;
64624 }
64625
64626
64627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64628   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64629   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64630
64631   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64632   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64633   if (!arg2) {
64634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64635     return ;
64636   }
64637   {
64638     try {
64639       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64640     } catch (std::out_of_range& e) {
64641       {
64642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64643       };
64644     } catch (std::exception& e) {
64645       {
64646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64647       };
64648     } catch (Dali::DaliException e) {
64649       {
64650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64651       };
64652     } catch (...) {
64653       {
64654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64655       };
64656     }
64657   }
64658
64659 }
64660
64661
64662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
64663   void * jresult ;
64664   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64665   Dali::Toolkit::Alignment::Padding *result = 0 ;
64666
64667   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64668   {
64669     try {
64670       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64671     } catch (std::out_of_range& e) {
64672       {
64673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64674       };
64675     } catch (std::exception& e) {
64676       {
64677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64678       };
64679     } catch (Dali::DaliException e) {
64680       {
64681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64682       };
64683     } catch (...) {
64684       {
64685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64686       };
64687     }
64688   }
64689
64690   jresult = (void *)result;
64691   return jresult;
64692 }
64693
64694
64695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
64696   void * jresult ;
64697   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64698   Dali::Toolkit::Alignment *arg2 = 0 ;
64699   Dali::Toolkit::Alignment *result = 0 ;
64700
64701   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64702   arg2 = (Dali::Toolkit::Alignment *)jarg2;
64703   if (!arg2) {
64704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64705     return 0;
64706   }
64707   {
64708     try {
64709       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
64710     } catch (std::out_of_range& e) {
64711       {
64712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64713       };
64714     } catch (std::exception& e) {
64715       {
64716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64717       };
64718     } catch (Dali::DaliException e) {
64719       {
64720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64721       };
64722     } catch (...) {
64723       {
64724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64725       };
64726     }
64727   }
64728
64729   jresult = (void *)result;
64730   return jresult;
64731 }
64732
64733
64734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
64735   int jresult ;
64736   int result;
64737
64738   result = (int)Dali::Toolkit::Button::Property::DISABLED;
64739   jresult = (int)result;
64740   return jresult;
64741 }
64742
64743
64744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
64745   int jresult ;
64746   int result;
64747
64748   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
64749   jresult = (int)result;
64750   return jresult;
64751 }
64752
64753
64754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
64755   int jresult ;
64756   int result;
64757
64758   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
64759   jresult = (int)result;
64760   return jresult;
64761 }
64762
64763
64764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
64765   int jresult ;
64766   int result;
64767
64768   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
64769   jresult = (int)result;
64770   return jresult;
64771 }
64772
64773
64774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
64775   int jresult ;
64776   int result;
64777
64778   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
64779   jresult = (int)result;
64780   return jresult;
64781 }
64782
64783
64784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
64785   int jresult ;
64786   int result;
64787
64788   result = (int)Dali::Toolkit::Button::Property::SELECTED;
64789   jresult = (int)result;
64790   return jresult;
64791 }
64792
64793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
64794   int jresult ;
64795   int result;
64796
64797   result = (int)Dali::Toolkit::Button::Property::LABEL;
64798   jresult = (int)result;
64799   return jresult;
64800 }
64801
64802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
64803   void * jresult ;
64804   Dali::Toolkit::Button::Property *result = 0 ;
64805
64806   {
64807     try {
64808       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
64809     } catch (std::out_of_range& e) {
64810       {
64811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64812       };
64813     } catch (std::exception& e) {
64814       {
64815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64816       };
64817     } catch (Dali::DaliException e) {
64818       {
64819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64820       };
64821     } catch (...) {
64822       {
64823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64824       };
64825     }
64826   }
64827
64828   jresult = (void *)result;
64829   return jresult;
64830 }
64831
64832
64833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
64834   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
64835
64836   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
64837   {
64838     try {
64839       delete arg1;
64840     } catch (std::out_of_range& e) {
64841       {
64842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64843       };
64844     } catch (std::exception& e) {
64845       {
64846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64847       };
64848     } catch (Dali::DaliException e) {
64849       {
64850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64851       };
64852     } catch (...) {
64853       {
64854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64855       };
64856     }
64857   }
64858
64859 }
64860
64861
64862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
64863   void * jresult ;
64864   Dali::Toolkit::Button *result = 0 ;
64865
64866   {
64867     try {
64868       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
64869     } catch (std::out_of_range& e) {
64870       {
64871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64872       };
64873     } catch (std::exception& e) {
64874       {
64875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64876       };
64877     } catch (Dali::DaliException e) {
64878       {
64879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64880       };
64881     } catch (...) {
64882       {
64883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64884       };
64885     }
64886   }
64887
64888   jresult = (void *)result;
64889   return jresult;
64890 }
64891
64892
64893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
64894   void * jresult ;
64895   Dali::Toolkit::Button *arg1 = 0 ;
64896   Dali::Toolkit::Button *result = 0 ;
64897
64898   arg1 = (Dali::Toolkit::Button *)jarg1;
64899   if (!arg1) {
64900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64901     return 0;
64902   }
64903   {
64904     try {
64905       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
64906     } catch (std::out_of_range& e) {
64907       {
64908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64909       };
64910     } catch (std::exception& e) {
64911       {
64912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64913       };
64914     } catch (Dali::DaliException e) {
64915       {
64916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64917       };
64918     } catch (...) {
64919       {
64920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64921       };
64922     }
64923   }
64924
64925   jresult = (void *)result;
64926   return jresult;
64927 }
64928
64929
64930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
64931   void * jresult ;
64932   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64933   Dali::Toolkit::Button *arg2 = 0 ;
64934   Dali::Toolkit::Button *result = 0 ;
64935
64936   arg1 = (Dali::Toolkit::Button *)jarg1;
64937   arg2 = (Dali::Toolkit::Button *)jarg2;
64938   if (!arg2) {
64939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64940     return 0;
64941   }
64942   {
64943     try {
64944       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
64945     } catch (std::out_of_range& e) {
64946       {
64947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64948       };
64949     } catch (std::exception& e) {
64950       {
64951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64952       };
64953     } catch (Dali::DaliException e) {
64954       {
64955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64956       };
64957     } catch (...) {
64958       {
64959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64960       };
64961     }
64962   }
64963
64964   jresult = (void *)result;
64965   return jresult;
64966 }
64967
64968
64969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
64970   void * jresult ;
64971   Dali::BaseHandle arg1 ;
64972   Dali::BaseHandle *argp1 ;
64973   Dali::Toolkit::Button result;
64974
64975   argp1 = (Dali::BaseHandle *)jarg1;
64976   if (!argp1) {
64977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64978     return 0;
64979   }
64980   arg1 = *argp1;
64981   {
64982     try {
64983       result = Dali::Toolkit::Button::DownCast(arg1);
64984     } catch (std::out_of_range& e) {
64985       {
64986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64987       };
64988     } catch (std::exception& e) {
64989       {
64990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64991       };
64992     } catch (Dali::DaliException e) {
64993       {
64994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64995       };
64996     } catch (...) {
64997       {
64998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64999       };
65000     }
65001   }
65002
65003   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65004   return jresult;
65005 }
65006
65007
65008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65009   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65010
65011   arg1 = (Dali::Toolkit::Button *)jarg1;
65012   {
65013     try {
65014       delete arg1;
65015     } catch (std::out_of_range& e) {
65016       {
65017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65018       };
65019     } catch (std::exception& e) {
65020       {
65021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65022       };
65023     } catch (Dali::DaliException e) {
65024       {
65025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65026       };
65027     } catch (...) {
65028       {
65029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65030       };
65031     }
65032   }
65033
65034 }
65035
65036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65037   void * jresult ;
65038   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65039   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65040
65041   arg1 = (Dali::Toolkit::Button *)jarg1;
65042   {
65043     try {
65044       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65045     } catch (std::out_of_range& e) {
65046       {
65047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65048       };
65049     } catch (std::exception& e) {
65050       {
65051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65052       };
65053     } catch (Dali::DaliException e) {
65054       {
65055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65056       };
65057     } catch (...) {
65058       {
65059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65060       };
65061     }
65062   }
65063
65064   jresult = (void *)result;
65065   return jresult;
65066 }
65067
65068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65069   void * jresult ;
65070   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65071   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65072
65073   arg1 = (Dali::Toolkit::Button *)jarg1;
65074   {
65075     try {
65076       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
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 = (void *)result;
65097   return jresult;
65098 }
65099
65100
65101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65102   void * jresult ;
65103   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65104   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65105
65106   arg1 = (Dali::Toolkit::Button *)jarg1;
65107   {
65108     try {
65109       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65110     } catch (std::out_of_range& e) {
65111       {
65112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65113       };
65114     } catch (std::exception& e) {
65115       {
65116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65117       };
65118     } catch (Dali::DaliException e) {
65119       {
65120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65121       };
65122     } catch (...) {
65123       {
65124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65125       };
65126     }
65127   }
65128
65129   jresult = (void *)result;
65130   return jresult;
65131 }
65132
65133
65134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65135   void * jresult ;
65136   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65137   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65138
65139   arg1 = (Dali::Toolkit::Button *)jarg1;
65140   {
65141     try {
65142       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65143     } catch (std::out_of_range& e) {
65144       {
65145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65146       };
65147     } catch (std::exception& e) {
65148       {
65149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65150       };
65151     } catch (Dali::DaliException e) {
65152       {
65153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65154       };
65155     } catch (...) {
65156       {
65157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65158       };
65159     }
65160   }
65161
65162   jresult = (void *)result;
65163   return jresult;
65164 }
65165
65166
65167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65168   void * jresult ;
65169   Dali::Toolkit::CheckBoxButton *result = 0 ;
65170
65171   {
65172     try {
65173       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65174     } catch (std::out_of_range& e) {
65175       {
65176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65177       };
65178     } catch (std::exception& e) {
65179       {
65180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65181       };
65182     } catch (Dali::DaliException e) {
65183       {
65184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65185       };
65186     } catch (...) {
65187       {
65188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65189       };
65190     }
65191   }
65192
65193   jresult = (void *)result;
65194   return jresult;
65195 }
65196
65197
65198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65199   void * jresult ;
65200   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65201   Dali::Toolkit::CheckBoxButton *result = 0 ;
65202
65203   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65204   if (!arg1) {
65205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65206     return 0;
65207   }
65208   {
65209     try {
65210       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65211     } catch (std::out_of_range& e) {
65212       {
65213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65214       };
65215     } catch (std::exception& e) {
65216       {
65217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65218       };
65219     } catch (Dali::DaliException e) {
65220       {
65221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65222       };
65223     } catch (...) {
65224       {
65225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65226       };
65227     }
65228   }
65229
65230   jresult = (void *)result;
65231   return jresult;
65232 }
65233
65234
65235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65236   void * jresult ;
65237   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65238   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65239   Dali::Toolkit::CheckBoxButton *result = 0 ;
65240
65241   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65242   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65243   if (!arg2) {
65244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65245     return 0;
65246   }
65247   {
65248     try {
65249       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65250     } catch (std::out_of_range& e) {
65251       {
65252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65253       };
65254     } catch (std::exception& e) {
65255       {
65256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65257       };
65258     } catch (Dali::DaliException e) {
65259       {
65260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65261       };
65262     } catch (...) {
65263       {
65264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65265       };
65266     }
65267   }
65268
65269   jresult = (void *)result;
65270   return jresult;
65271 }
65272
65273
65274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65275   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65276
65277   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65278   {
65279     try {
65280       delete arg1;
65281     } catch (std::out_of_range& e) {
65282       {
65283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65284       };
65285     } catch (std::exception& e) {
65286       {
65287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65288       };
65289     } catch (Dali::DaliException e) {
65290       {
65291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65292       };
65293     } catch (...) {
65294       {
65295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65296       };
65297     }
65298   }
65299
65300 }
65301
65302
65303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65304   void * jresult ;
65305   Dali::Toolkit::CheckBoxButton result;
65306
65307   {
65308     try {
65309       result = Dali::Toolkit::CheckBoxButton::New();
65310     } catch (std::out_of_range& e) {
65311       {
65312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65313       };
65314     } catch (std::exception& e) {
65315       {
65316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65317       };
65318     } catch (Dali::DaliException e) {
65319       {
65320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65321       };
65322     } catch (...) {
65323       {
65324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65325       };
65326     }
65327   }
65328
65329   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65330   return jresult;
65331 }
65332
65333
65334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65335   void * jresult ;
65336   Dali::BaseHandle arg1 ;
65337   Dali::BaseHandle *argp1 ;
65338   Dali::Toolkit::CheckBoxButton result;
65339
65340   argp1 = (Dali::BaseHandle *)jarg1;
65341   if (!argp1) {
65342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65343     return 0;
65344   }
65345   arg1 = *argp1;
65346   {
65347     try {
65348       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65349     } catch (std::out_of_range& e) {
65350       {
65351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65352       };
65353     } catch (std::exception& e) {
65354       {
65355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65356       };
65357     } catch (Dali::DaliException e) {
65358       {
65359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65360       };
65361     } catch (...) {
65362       {
65363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65364       };
65365     }
65366   }
65367
65368   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65369   return jresult;
65370 }
65371
65372
65373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
65374   int jresult ;
65375   int result;
65376
65377   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65378   jresult = (int)result;
65379   return jresult;
65380 }
65381
65382
65383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
65384   int jresult ;
65385   int result;
65386
65387   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65388   jresult = (int)result;
65389   return jresult;
65390 }
65391
65392
65393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
65394   void * jresult ;
65395   Dali::Toolkit::PushButton::Property *result = 0 ;
65396
65397   {
65398     try {
65399       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65400     } catch (std::out_of_range& e) {
65401       {
65402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65403       };
65404     } catch (std::exception& e) {
65405       {
65406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65407       };
65408     } catch (Dali::DaliException e) {
65409       {
65410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65411       };
65412     } catch (...) {
65413       {
65414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65415       };
65416     }
65417   }
65418
65419   jresult = (void *)result;
65420   return jresult;
65421 }
65422
65423
65424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
65425   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65426
65427   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65428   {
65429     try {
65430       delete arg1;
65431     } catch (std::out_of_range& e) {
65432       {
65433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65434       };
65435     } catch (std::exception& e) {
65436       {
65437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65438       };
65439     } catch (Dali::DaliException e) {
65440       {
65441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65442       };
65443     } catch (...) {
65444       {
65445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65446       };
65447     }
65448   }
65449
65450 }
65451
65452
65453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65454   void * jresult ;
65455   Dali::Toolkit::PushButton *result = 0 ;
65456
65457   {
65458     try {
65459       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65460     } catch (std::out_of_range& e) {
65461       {
65462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65463       };
65464     } catch (std::exception& e) {
65465       {
65466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65467       };
65468     } catch (Dali::DaliException e) {
65469       {
65470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65471       };
65472     } catch (...) {
65473       {
65474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65475       };
65476     }
65477   }
65478
65479   jresult = (void *)result;
65480   return jresult;
65481 }
65482
65483
65484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
65485   void * jresult ;
65486   Dali::Toolkit::PushButton *arg1 = 0 ;
65487   Dali::Toolkit::PushButton *result = 0 ;
65488
65489   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65490   if (!arg1) {
65491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65492     return 0;
65493   }
65494   {
65495     try {
65496       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65497     } catch (std::out_of_range& e) {
65498       {
65499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65500       };
65501     } catch (std::exception& e) {
65502       {
65503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65504       };
65505     } catch (Dali::DaliException e) {
65506       {
65507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65508       };
65509     } catch (...) {
65510       {
65511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65512       };
65513     }
65514   }
65515
65516   jresult = (void *)result;
65517   return jresult;
65518 }
65519
65520
65521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
65522   void * jresult ;
65523   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65524   Dali::Toolkit::PushButton *arg2 = 0 ;
65525   Dali::Toolkit::PushButton *result = 0 ;
65526
65527   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65528   arg2 = (Dali::Toolkit::PushButton *)jarg2;
65529   if (!arg2) {
65530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65531     return 0;
65532   }
65533   {
65534     try {
65535       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
65536     } catch (std::out_of_range& e) {
65537       {
65538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65539       };
65540     } catch (std::exception& e) {
65541       {
65542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65543       };
65544     } catch (Dali::DaliException e) {
65545       {
65546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65547       };
65548     } catch (...) {
65549       {
65550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65551       };
65552     }
65553   }
65554
65555   jresult = (void *)result;
65556   return jresult;
65557 }
65558
65559
65560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
65561   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65562
65563   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65564   {
65565     try {
65566       delete arg1;
65567     } catch (std::out_of_range& e) {
65568       {
65569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65570       };
65571     } catch (std::exception& e) {
65572       {
65573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65574       };
65575     } catch (Dali::DaliException e) {
65576       {
65577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65578       };
65579     } catch (...) {
65580       {
65581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65582       };
65583     }
65584   }
65585
65586 }
65587
65588
65589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
65590   void * jresult ;
65591   Dali::Toolkit::PushButton result;
65592
65593   {
65594     try {
65595       result = Dali::Toolkit::PushButton::New();
65596     } catch (std::out_of_range& e) {
65597       {
65598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65599       };
65600     } catch (std::exception& e) {
65601       {
65602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65603       };
65604     } catch (Dali::DaliException e) {
65605       {
65606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65607       };
65608     } catch (...) {
65609       {
65610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65611       };
65612     }
65613   }
65614
65615   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65616   return jresult;
65617 }
65618
65619
65620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65621   void * jresult ;
65622   Dali::BaseHandle arg1 ;
65623   Dali::BaseHandle *argp1 ;
65624   Dali::Toolkit::PushButton result;
65625
65626   argp1 = (Dali::BaseHandle *)jarg1;
65627   if (!argp1) {
65628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65629     return 0;
65630   }
65631   arg1 = *argp1;
65632   {
65633     try {
65634       result = Dali::Toolkit::PushButton::DownCast(arg1);
65635     } catch (std::out_of_range& e) {
65636       {
65637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65638       };
65639     } catch (std::exception& e) {
65640       {
65641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65642       };
65643     } catch (Dali::DaliException e) {
65644       {
65645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65646       };
65647     } catch (...) {
65648       {
65649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65650       };
65651     }
65652   }
65653
65654   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65655   return jresult;
65656 }
65657
65658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65659   void * jresult ;
65660   Dali::Toolkit::RadioButton *result = 0 ;
65661
65662   {
65663     try {
65664       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65665     } catch (std::out_of_range& e) {
65666       {
65667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65668       };
65669     } catch (std::exception& e) {
65670       {
65671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65672       };
65673     } catch (Dali::DaliException e) {
65674       {
65675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65676       };
65677     } catch (...) {
65678       {
65679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65680       };
65681     }
65682   }
65683
65684   jresult = (void *)result;
65685   return jresult;
65686 }
65687
65688
65689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65690   void * jresult ;
65691   Dali::Toolkit::RadioButton *arg1 = 0 ;
65692   Dali::Toolkit::RadioButton *result = 0 ;
65693
65694   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65695   if (!arg1) {
65696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65697     return 0;
65698   }
65699   {
65700     try {
65701       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65702     } catch (std::out_of_range& e) {
65703       {
65704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65705       };
65706     } catch (std::exception& e) {
65707       {
65708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65709       };
65710     } catch (Dali::DaliException e) {
65711       {
65712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65713       };
65714     } catch (...) {
65715       {
65716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65717       };
65718     }
65719   }
65720
65721   jresult = (void *)result;
65722   return jresult;
65723 }
65724
65725
65726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65727   void * jresult ;
65728   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65729   Dali::Toolkit::RadioButton *arg2 = 0 ;
65730   Dali::Toolkit::RadioButton *result = 0 ;
65731
65732   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65733   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65734   if (!arg2) {
65735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65736     return 0;
65737   }
65738   {
65739     try {
65740       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65741     } catch (std::out_of_range& e) {
65742       {
65743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65744       };
65745     } catch (std::exception& e) {
65746       {
65747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65748       };
65749     } catch (Dali::DaliException e) {
65750       {
65751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65752       };
65753     } catch (...) {
65754       {
65755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65756       };
65757     }
65758   }
65759
65760   jresult = (void *)result;
65761   return jresult;
65762 }
65763
65764
65765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65766   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65767
65768   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65769   {
65770     try {
65771       delete arg1;
65772     } catch (std::out_of_range& e) {
65773       {
65774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65775       };
65776     } catch (std::exception& e) {
65777       {
65778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65779       };
65780     } catch (Dali::DaliException e) {
65781       {
65782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65783       };
65784     } catch (...) {
65785       {
65786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65787       };
65788     }
65789   }
65790
65791 }
65792
65793
65794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65795   void * jresult ;
65796   Dali::Toolkit::RadioButton result;
65797
65798   {
65799     try {
65800       result = Dali::Toolkit::RadioButton::New();
65801     } catch (std::out_of_range& e) {
65802       {
65803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65804       };
65805     } catch (std::exception& e) {
65806       {
65807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65808       };
65809     } catch (Dali::DaliException e) {
65810       {
65811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65812       };
65813     } catch (...) {
65814       {
65815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65816       };
65817     }
65818   }
65819
65820   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65821   return jresult;
65822 }
65823
65824
65825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
65826   void * jresult ;
65827   std::string *arg1 = 0 ;
65828   Dali::Toolkit::RadioButton result;
65829
65830   if (!jarg1) {
65831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65832     return 0;
65833   }
65834   std::string arg1_str(jarg1);
65835   arg1 = &arg1_str;
65836   {
65837     try {
65838       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
65839     } catch (std::out_of_range& e) {
65840       {
65841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65842       };
65843     } catch (std::exception& e) {
65844       {
65845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65846       };
65847     } catch (Dali::DaliException e) {
65848       {
65849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65850       };
65851     } catch (...) {
65852       {
65853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65854       };
65855     }
65856   }
65857
65858   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65859
65860   //argout typemap for const std::string&
65861
65862   return jresult;
65863 }
65864
65865
65866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
65867   void * jresult ;
65868   Dali::BaseHandle arg1 ;
65869   Dali::BaseHandle *argp1 ;
65870   Dali::Toolkit::RadioButton result;
65871
65872   argp1 = (Dali::BaseHandle *)jarg1;
65873   if (!argp1) {
65874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65875     return 0;
65876   }
65877   arg1 = *argp1;
65878   {
65879     try {
65880       result = Dali::Toolkit::RadioButton::DownCast(arg1);
65881     } catch (std::out_of_range& e) {
65882       {
65883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65884       };
65885     } catch (std::exception& e) {
65886       {
65887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65888       };
65889     } catch (Dali::DaliException e) {
65890       {
65891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65892       };
65893     } catch (...) {
65894       {
65895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65896       };
65897     }
65898   }
65899
65900   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65901   return jresult;
65902 }
65903
65904
65905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
65906   int jresult ;
65907   int result;
65908
65909   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
65910   jresult = (int)result;
65911   return jresult;
65912 }
65913
65914
65915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
65916   int jresult ;
65917   int result;
65918
65919   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
65920   jresult = (int)result;
65921   return jresult;
65922 }
65923
65924
65925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
65926   int jresult ;
65927   int result;
65928
65929   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
65930   jresult = (int)result;
65931   return jresult;
65932 }
65933
65934
65935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
65936   int jresult ;
65937   int result;
65938
65939   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
65940   jresult = (int)result;
65941   return jresult;
65942 }
65943
65944
65945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
65946   int jresult ;
65947   int result;
65948
65949   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
65950   jresult = (int)result;
65951   return jresult;
65952 }
65953
65954
65955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
65956   int jresult ;
65957   int result;
65958
65959   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
65960   jresult = (int)result;
65961   return jresult;
65962 }
65963
65964
65965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
65966   void * jresult ;
65967   Dali::Toolkit::FlexContainer::Property *result = 0 ;
65968
65969   {
65970     try {
65971       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
65972     } catch (std::out_of_range& e) {
65973       {
65974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65975       };
65976     } catch (std::exception& e) {
65977       {
65978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65979       };
65980     } catch (Dali::DaliException e) {
65981       {
65982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65983       };
65984     } catch (...) {
65985       {
65986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65987       };
65988     }
65989   }
65990
65991   jresult = (void *)result;
65992   return jresult;
65993 }
65994
65995
65996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
65997   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
65998
65999   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66000   {
66001     try {
66002       delete arg1;
66003     } catch (std::out_of_range& e) {
66004       {
66005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66006       };
66007     } catch (std::exception& e) {
66008       {
66009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66010       };
66011     } catch (Dali::DaliException e) {
66012       {
66013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66014       };
66015     } catch (...) {
66016       {
66017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66018       };
66019     }
66020   }
66021
66022 }
66023
66024
66025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66026   int jresult ;
66027   int result;
66028
66029   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66030   jresult = (int)result;
66031   return jresult;
66032 }
66033
66034
66035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66036   int jresult ;
66037   int result;
66038
66039   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66040   jresult = (int)result;
66041   return jresult;
66042 }
66043
66044
66045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66046   int jresult ;
66047   int result;
66048
66049   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66050   jresult = (int)result;
66051   return jresult;
66052 }
66053
66054
66055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66056   void * jresult ;
66057   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66058
66059   {
66060     try {
66061       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66062     } catch (std::out_of_range& e) {
66063       {
66064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66065       };
66066     } catch (std::exception& e) {
66067       {
66068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66069       };
66070     } catch (Dali::DaliException e) {
66071       {
66072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66073       };
66074     } catch (...) {
66075       {
66076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66077       };
66078     }
66079   }
66080
66081   jresult = (void *)result;
66082   return jresult;
66083 }
66084
66085
66086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66087   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66088
66089   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66090   {
66091     try {
66092       delete arg1;
66093     } catch (std::out_of_range& e) {
66094       {
66095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66096       };
66097     } catch (std::exception& e) {
66098       {
66099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66100       };
66101     } catch (Dali::DaliException e) {
66102       {
66103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66104       };
66105     } catch (...) {
66106       {
66107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66108       };
66109     }
66110   }
66111
66112 }
66113
66114
66115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66116   void * jresult ;
66117   Dali::Toolkit::FlexContainer *result = 0 ;
66118
66119   {
66120     try {
66121       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66122     } catch (std::out_of_range& e) {
66123       {
66124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66125       };
66126     } catch (std::exception& e) {
66127       {
66128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66129       };
66130     } catch (Dali::DaliException e) {
66131       {
66132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66133       };
66134     } catch (...) {
66135       {
66136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66137       };
66138     }
66139   }
66140
66141   jresult = (void *)result;
66142   return jresult;
66143 }
66144
66145
66146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66147   void * jresult ;
66148   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66149   Dali::Toolkit::FlexContainer *result = 0 ;
66150
66151   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66152   if (!arg1) {
66153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66154     return 0;
66155   }
66156   {
66157     try {
66158       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66159     } catch (std::out_of_range& e) {
66160       {
66161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66162       };
66163     } catch (std::exception& e) {
66164       {
66165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66166       };
66167     } catch (Dali::DaliException e) {
66168       {
66169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66170       };
66171     } catch (...) {
66172       {
66173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66174       };
66175     }
66176   }
66177
66178   jresult = (void *)result;
66179   return jresult;
66180 }
66181
66182
66183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66184   void * jresult ;
66185   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66186   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66187   Dali::Toolkit::FlexContainer *result = 0 ;
66188
66189   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66190   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66191   if (!arg2) {
66192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66193     return 0;
66194   }
66195   {
66196     try {
66197       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66198     } catch (std::out_of_range& e) {
66199       {
66200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66201       };
66202     } catch (std::exception& e) {
66203       {
66204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66205       };
66206     } catch (Dali::DaliException e) {
66207       {
66208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66209       };
66210     } catch (...) {
66211       {
66212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66213       };
66214     }
66215   }
66216
66217   jresult = (void *)result;
66218   return jresult;
66219 }
66220
66221
66222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
66223   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66224
66225   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66226   {
66227     try {
66228       delete arg1;
66229     } catch (std::out_of_range& e) {
66230       {
66231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66232       };
66233     } catch (std::exception& e) {
66234       {
66235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66236       };
66237     } catch (Dali::DaliException e) {
66238       {
66239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66240       };
66241     } catch (...) {
66242       {
66243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66244       };
66245     }
66246   }
66247
66248 }
66249
66250
66251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
66252   void * jresult ;
66253   Dali::Toolkit::FlexContainer result;
66254
66255   {
66256     try {
66257       result = Dali::Toolkit::FlexContainer::New();
66258     } catch (std::out_of_range& e) {
66259       {
66260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66261       };
66262     } catch (std::exception& e) {
66263       {
66264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66265       };
66266     } catch (Dali::DaliException e) {
66267       {
66268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66269       };
66270     } catch (...) {
66271       {
66272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66273       };
66274     }
66275   }
66276
66277   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66278   return jresult;
66279 }
66280
66281
66282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66283   void * jresult ;
66284   Dali::BaseHandle arg1 ;
66285   Dali::BaseHandle *argp1 ;
66286   Dali::Toolkit::FlexContainer result;
66287
66288   argp1 = (Dali::BaseHandle *)jarg1;
66289   if (!argp1) {
66290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66291     return 0;
66292   }
66293   arg1 = *argp1;
66294   {
66295     try {
66296       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66297     } catch (std::out_of_range& e) {
66298       {
66299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66300       };
66301     } catch (std::exception& e) {
66302       {
66303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66304       };
66305     } catch (Dali::DaliException e) {
66306       {
66307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66308       };
66309     } catch (...) {
66310       {
66311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66312       };
66313     }
66314   }
66315
66316   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66317   return jresult;
66318 }
66319
66320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
66321   int jresult ;
66322   int result;
66323
66324   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66325   jresult = (int)result;
66326   return jresult;
66327 }
66328
66329
66330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66331   int jresult ;
66332   int result;
66333
66334   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66335   jresult = (int)result;
66336   return jresult;
66337 }
66338
66339
66340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
66341   int jresult ;
66342   int result;
66343
66344   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66345   jresult = (int)result;
66346   return jresult;
66347 }
66348
66349
66350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
66351   void * jresult ;
66352   Dali::Toolkit::ImageView::Property *result = 0 ;
66353
66354   {
66355     try {
66356       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
66357     } catch (std::out_of_range& e) {
66358       {
66359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66360       };
66361     } catch (std::exception& e) {
66362       {
66363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66364       };
66365     } catch (Dali::DaliException e) {
66366       {
66367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66368       };
66369     } catch (...) {
66370       {
66371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66372       };
66373     }
66374   }
66375
66376   jresult = (void *)result;
66377   return jresult;
66378 }
66379
66380
66381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
66382   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66383
66384   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66385   {
66386     try {
66387       delete arg1;
66388     } catch (std::out_of_range& e) {
66389       {
66390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66391       };
66392     } catch (std::exception& e) {
66393       {
66394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66395       };
66396     } catch (Dali::DaliException e) {
66397       {
66398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66399       };
66400     } catch (...) {
66401       {
66402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66403       };
66404     }
66405   }
66406
66407 }
66408
66409
66410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66411   void * jresult ;
66412   Dali::Toolkit::ImageView *result = 0 ;
66413
66414   {
66415     try {
66416       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66417     } catch (std::out_of_range& e) {
66418       {
66419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66420       };
66421     } catch (std::exception& e) {
66422       {
66423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66424       };
66425     } catch (Dali::DaliException e) {
66426       {
66427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66428       };
66429     } catch (...) {
66430       {
66431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66432       };
66433     }
66434   }
66435
66436   jresult = (void *)result;
66437   return jresult;
66438 }
66439
66440
66441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66442   void * jresult ;
66443   Dali::Toolkit::ImageView result;
66444
66445   {
66446     try {
66447       result = Dali::Toolkit::ImageView::New();
66448     } catch (std::out_of_range& e) {
66449       {
66450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66451       };
66452     } catch (std::exception& e) {
66453       {
66454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66455       };
66456     } catch (Dali::DaliException e) {
66457       {
66458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66459       };
66460     } catch (...) {
66461       {
66462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66463       };
66464     }
66465   }
66466
66467   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66468   return jresult;
66469 }
66470
66471
66472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66473   void * jresult ;
66474   std::string *arg1 = 0 ;
66475   Dali::Toolkit::ImageView result;
66476
66477   if (!jarg1) {
66478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66479     return 0;
66480   }
66481   std::string arg1_str(jarg1);
66482   arg1 = &arg1_str;
66483   {
66484     try {
66485       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66486     } catch (std::out_of_range& e) {
66487       {
66488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66489       };
66490     } catch (std::exception& e) {
66491       {
66492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66493       };
66494     } catch (Dali::DaliException e) {
66495       {
66496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66497       };
66498     } catch (...) {
66499       {
66500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66501       };
66502     }
66503   }
66504
66505   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66506
66507   //argout typemap for const std::string&
66508
66509   return jresult;
66510 }
66511
66512
66513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66514   void * jresult ;
66515   std::string *arg1 = 0 ;
66516   Dali::ImageDimensions arg2 ;
66517   Dali::ImageDimensions *argp2 ;
66518   Dali::Toolkit::ImageView result;
66519
66520   if (!jarg1) {
66521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66522     return 0;
66523   }
66524   std::string arg1_str(jarg1);
66525   arg1 = &arg1_str;
66526   argp2 = (Dali::ImageDimensions *)jarg2;
66527   if (!argp2) {
66528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66529     return 0;
66530   }
66531   arg2 = *argp2;
66532   {
66533     try {
66534       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66535     } catch (std::out_of_range& e) {
66536       {
66537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66538       };
66539     } catch (std::exception& e) {
66540       {
66541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66542       };
66543     } catch (Dali::DaliException e) {
66544       {
66545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66546       };
66547     } catch (...) {
66548       {
66549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66550       };
66551     }
66552   }
66553
66554   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66555
66556   //argout typemap for const std::string&
66557
66558   return jresult;
66559 }
66560
66561
66562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66563   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66564
66565   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66566   {
66567     try {
66568       delete arg1;
66569     } catch (std::out_of_range& e) {
66570       {
66571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66572       };
66573     } catch (std::exception& e) {
66574       {
66575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66576       };
66577     } catch (Dali::DaliException e) {
66578       {
66579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66580       };
66581     } catch (...) {
66582       {
66583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66584       };
66585     }
66586   }
66587
66588 }
66589
66590
66591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66592   void * jresult ;
66593   Dali::Toolkit::ImageView *arg1 = 0 ;
66594   Dali::Toolkit::ImageView *result = 0 ;
66595
66596   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66597   if (!arg1) {
66598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66599     return 0;
66600   }
66601   {
66602     try {
66603       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66604     } catch (std::out_of_range& e) {
66605       {
66606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66607       };
66608     } catch (std::exception& e) {
66609       {
66610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66611       };
66612     } catch (Dali::DaliException e) {
66613       {
66614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66615       };
66616     } catch (...) {
66617       {
66618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66619       };
66620     }
66621   }
66622
66623   jresult = (void *)result;
66624   return jresult;
66625 }
66626
66627
66628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66629   void * jresult ;
66630   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66631   Dali::Toolkit::ImageView *arg2 = 0 ;
66632   Dali::Toolkit::ImageView *result = 0 ;
66633
66634   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66635   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66636   if (!arg2) {
66637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66638     return 0;
66639   }
66640   {
66641     try {
66642       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66643     } catch (std::out_of_range& e) {
66644       {
66645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66646       };
66647     } catch (std::exception& e) {
66648       {
66649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66650       };
66651     } catch (Dali::DaliException e) {
66652       {
66653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66654       };
66655     } catch (...) {
66656       {
66657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66658       };
66659     }
66660   }
66661
66662   jresult = (void *)result;
66663   return jresult;
66664 }
66665
66666
66667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
66668   void * jresult ;
66669   Dali::BaseHandle arg1 ;
66670   Dali::BaseHandle *argp1 ;
66671   Dali::Toolkit::ImageView result;
66672
66673   argp1 = (Dali::BaseHandle *)jarg1;
66674   if (!argp1) {
66675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66676     return 0;
66677   }
66678   arg1 = *argp1;
66679   {
66680     try {
66681       result = Dali::Toolkit::ImageView::DownCast(arg1);
66682     } catch (std::out_of_range& e) {
66683       {
66684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66685       };
66686     } catch (std::exception& e) {
66687       {
66688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66689       };
66690     } catch (Dali::DaliException e) {
66691       {
66692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66693       };
66694     } catch (...) {
66695       {
66696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66697       };
66698     }
66699   }
66700
66701   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66702   return jresult;
66703 }
66704
66705
66706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
66707   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66708   std::string *arg2 = 0 ;
66709
66710   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66711   if (!jarg2) {
66712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66713     return ;
66714   }
66715   std::string arg2_str(jarg2);
66716   arg2 = &arg2_str;
66717   {
66718     try {
66719       (arg1)->SetImage((std::string const &)*arg2);
66720     } catch (std::out_of_range& e) {
66721       {
66722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66723       };
66724     } catch (std::exception& e) {
66725       {
66726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66727       };
66728     } catch (Dali::DaliException e) {
66729       {
66730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66731       };
66732     } catch (...) {
66733       {
66734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66735       };
66736     }
66737   }
66738
66739
66740   //argout typemap for const std::string&
66741
66742 }
66743
66744
66745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66746   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66747   std::string *arg2 = 0 ;
66748   Dali::ImageDimensions arg3 ;
66749   Dali::ImageDimensions *argp3 ;
66750
66751   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66752   if (!jarg2) {
66753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66754     return ;
66755   }
66756   std::string arg2_str(jarg2);
66757   arg2 = &arg2_str;
66758   argp3 = (Dali::ImageDimensions *)jarg3;
66759   if (!argp3) {
66760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66761     return ;
66762   }
66763   arg3 = *argp3;
66764   {
66765     try {
66766       (arg1)->SetImage((std::string const &)*arg2,arg3);
66767     } catch (std::out_of_range& e) {
66768       {
66769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66770       };
66771     } catch (std::exception& e) {
66772       {
66773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66774       };
66775     } catch (Dali::DaliException e) {
66776       {
66777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66778       };
66779     } catch (...) {
66780       {
66781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66782       };
66783     }
66784   }
66785
66786
66787   //argout typemap for const std::string&
66788
66789 }
66790
66791
66792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66793   int jresult ;
66794   int result;
66795
66796   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66797   jresult = (int)result;
66798   return jresult;
66799 }
66800
66801
66802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66803   int jresult ;
66804   int result;
66805
66806   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66807   jresult = (int)result;
66808   return jresult;
66809 }
66810
66811
66812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66813   int jresult ;
66814   int result;
66815
66816   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66817   jresult = (int)result;
66818   return jresult;
66819 }
66820
66821
66822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66823   int jresult ;
66824   int result;
66825
66826   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
66827   jresult = (int)result;
66828   return jresult;
66829 }
66830
66831
66832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
66833   int jresult ;
66834   int result;
66835
66836   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
66837   jresult = (int)result;
66838   return jresult;
66839 }
66840
66841
66842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
66843   int jresult ;
66844   int result;
66845
66846   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
66847   jresult = (int)result;
66848   return jresult;
66849 }
66850
66851
66852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
66853   int jresult ;
66854   int result;
66855
66856   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
66857   jresult = (int)result;
66858   return jresult;
66859 }
66860
66861
66862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
66863   int jresult ;
66864   int result;
66865
66866   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
66867   jresult = (int)result;
66868   return jresult;
66869 }
66870
66871
66872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
66873   void * jresult ;
66874   Dali::Toolkit::Model3dView::Property *result = 0 ;
66875
66876   {
66877     try {
66878       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
66879     } catch (std::out_of_range& e) {
66880       {
66881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66882       };
66883     } catch (std::exception& e) {
66884       {
66885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66886       };
66887     } catch (Dali::DaliException e) {
66888       {
66889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66890       };
66891     } catch (...) {
66892       {
66893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66894       };
66895     }
66896   }
66897
66898   jresult = (void *)result;
66899   return jresult;
66900 }
66901
66902
66903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
66904   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
66905
66906   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
66907   {
66908     try {
66909       delete arg1;
66910     } catch (std::out_of_range& e) {
66911       {
66912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66913       };
66914     } catch (std::exception& e) {
66915       {
66916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66917       };
66918     } catch (Dali::DaliException e) {
66919       {
66920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66921       };
66922     } catch (...) {
66923       {
66924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66925       };
66926     }
66927   }
66928
66929 }
66930
66931
66932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
66933   void * jresult ;
66934   Dali::Toolkit::Model3dView result;
66935
66936   {
66937     try {
66938       result = Dali::Toolkit::Model3dView::New();
66939     } catch (std::out_of_range& e) {
66940       {
66941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66942       };
66943     } catch (std::exception& e) {
66944       {
66945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66946       };
66947     } catch (Dali::DaliException e) {
66948       {
66949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66950       };
66951     } catch (...) {
66952       {
66953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66954       };
66955     }
66956   }
66957
66958   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66959   return jresult;
66960 }
66961
66962
66963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
66964   void * jresult ;
66965   std::string *arg1 = 0 ;
66966   std::string *arg2 = 0 ;
66967   std::string *arg3 = 0 ;
66968   Dali::Toolkit::Model3dView result;
66969
66970   if (!jarg1) {
66971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66972     return 0;
66973   }
66974   std::string arg1_str(jarg1);
66975   arg1 = &arg1_str;
66976   if (!jarg2) {
66977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66978     return 0;
66979   }
66980   std::string arg2_str(jarg2);
66981   arg2 = &arg2_str;
66982   if (!jarg3) {
66983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66984     return 0;
66985   }
66986   std::string arg3_str(jarg3);
66987   arg3 = &arg3_str;
66988   {
66989     try {
66990       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
66991     } catch (std::out_of_range& e) {
66992       {
66993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66994       };
66995     } catch (std::exception& e) {
66996       {
66997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66998       };
66999     } catch (Dali::DaliException e) {
67000       {
67001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67002       };
67003     } catch (...) {
67004       {
67005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67006       };
67007     }
67008   }
67009
67010   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67011
67012   //argout typemap for const std::string&
67013
67014
67015   //argout typemap for const std::string&
67016
67017
67018   //argout typemap for const std::string&
67019
67020   return jresult;
67021 }
67022
67023
67024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67025   void * jresult ;
67026   Dali::Toolkit::Model3dView *result = 0 ;
67027
67028   {
67029     try {
67030       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67031     } catch (std::out_of_range& e) {
67032       {
67033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67034       };
67035     } catch (std::exception& e) {
67036       {
67037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67038       };
67039     } catch (Dali::DaliException e) {
67040       {
67041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67042       };
67043     } catch (...) {
67044       {
67045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67046       };
67047     }
67048   }
67049
67050   jresult = (void *)result;
67051   return jresult;
67052 }
67053
67054
67055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67056   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67057
67058   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67059   {
67060     try {
67061       delete arg1;
67062     } catch (std::out_of_range& e) {
67063       {
67064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67065       };
67066     } catch (std::exception& e) {
67067       {
67068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67069       };
67070     } catch (Dali::DaliException e) {
67071       {
67072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67073       };
67074     } catch (...) {
67075       {
67076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67077       };
67078     }
67079   }
67080
67081 }
67082
67083
67084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67085   void * jresult ;
67086   Dali::Toolkit::Model3dView *arg1 = 0 ;
67087   Dali::Toolkit::Model3dView *result = 0 ;
67088
67089   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67090   if (!arg1) {
67091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67092     return 0;
67093   }
67094   {
67095     try {
67096       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67097     } catch (std::out_of_range& e) {
67098       {
67099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67100       };
67101     } catch (std::exception& e) {
67102       {
67103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67104       };
67105     } catch (Dali::DaliException e) {
67106       {
67107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67108       };
67109     } catch (...) {
67110       {
67111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67112       };
67113     }
67114   }
67115
67116   jresult = (void *)result;
67117   return jresult;
67118 }
67119
67120
67121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67122   void * jresult ;
67123   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67124   Dali::Toolkit::Model3dView *arg2 = 0 ;
67125   Dali::Toolkit::Model3dView *result = 0 ;
67126
67127   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67128   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67129   if (!arg2) {
67130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67131     return 0;
67132   }
67133   {
67134     try {
67135       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67136     } catch (std::out_of_range& e) {
67137       {
67138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67139       };
67140     } catch (std::exception& e) {
67141       {
67142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67143       };
67144     } catch (Dali::DaliException e) {
67145       {
67146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67147       };
67148     } catch (...) {
67149       {
67150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67151       };
67152     }
67153   }
67154
67155   jresult = (void *)result;
67156   return jresult;
67157 }
67158
67159
67160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67161   void * jresult ;
67162   Dali::BaseHandle arg1 ;
67163   Dali::BaseHandle *argp1 ;
67164   Dali::Toolkit::Model3dView result;
67165
67166   argp1 = (Dali::BaseHandle *)jarg1;
67167   if (!argp1) {
67168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67169     return 0;
67170   }
67171   arg1 = *argp1;
67172   {
67173     try {
67174       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67175     } catch (std::out_of_range& e) {
67176       {
67177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67178       };
67179     } catch (std::exception& e) {
67180       {
67181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67182       };
67183     } catch (Dali::DaliException e) {
67184       {
67185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67186       };
67187     } catch (...) {
67188       {
67189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67190       };
67191     }
67192   }
67193
67194   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67195   return jresult;
67196 }
67197
67198
67199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67200   int jresult ;
67201   int result;
67202
67203   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67204   jresult = (int)result;
67205   return jresult;
67206 }
67207
67208
67209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67210   int jresult ;
67211   int result;
67212
67213   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67214   jresult = (int)result;
67215   return jresult;
67216 }
67217
67218
67219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67220   int jresult ;
67221   int result;
67222
67223   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67224   jresult = (int)result;
67225   return jresult;
67226 }
67227
67228
67229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67230   int jresult ;
67231   int result;
67232
67233   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67234   jresult = (int)result;
67235   return jresult;
67236 }
67237
67238
67239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67240   int jresult ;
67241   int result;
67242
67243   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67244   jresult = (int)result;
67245   return jresult;
67246 }
67247
67248
67249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67250   int jresult ;
67251   int result;
67252
67253   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67254   jresult = (int)result;
67255   return jresult;
67256 }
67257
67258
67259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67260   int jresult ;
67261   int result;
67262
67263   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67264   jresult = (int)result;
67265   return jresult;
67266 }
67267
67268
67269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67270   int jresult ;
67271   int result;
67272
67273   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67274   jresult = (int)result;
67275   return jresult;
67276 }
67277
67278
67279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67280   int jresult ;
67281   int result;
67282
67283   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67284   jresult = (int)result;
67285   return jresult;
67286 }
67287
67288
67289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67290   void * jresult ;
67291   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67292
67293   {
67294     try {
67295       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67296     } catch (std::out_of_range& e) {
67297       {
67298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67299       };
67300     } catch (std::exception& e) {
67301       {
67302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67303       };
67304     } catch (Dali::DaliException e) {
67305       {
67306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67307       };
67308     } catch (...) {
67309       {
67310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67311       };
67312     }
67313   }
67314
67315   jresult = (void *)result;
67316   return jresult;
67317 }
67318
67319
67320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67321   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67322
67323   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67324   {
67325     try {
67326       delete arg1;
67327     } catch (std::out_of_range& e) {
67328       {
67329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67330       };
67331     } catch (std::exception& e) {
67332       {
67333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67334       };
67335     } catch (Dali::DaliException e) {
67336       {
67337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67338       };
67339     } catch (...) {
67340       {
67341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67342       };
67343     }
67344   }
67345
67346 }
67347
67348
67349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
67350   void * jresult ;
67351   Dali::Toolkit::ScrollBar *result = 0 ;
67352
67353   {
67354     try {
67355       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67356     } catch (std::out_of_range& e) {
67357       {
67358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67359       };
67360     } catch (std::exception& e) {
67361       {
67362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67363       };
67364     } catch (Dali::DaliException e) {
67365       {
67366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67367       };
67368     } catch (...) {
67369       {
67370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67371       };
67372     }
67373   }
67374
67375   jresult = (void *)result;
67376   return jresult;
67377 }
67378
67379
67380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
67381   void * jresult ;
67382   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67383   Dali::Toolkit::ScrollBar *result = 0 ;
67384
67385   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67386   if (!arg1) {
67387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67388     return 0;
67389   }
67390   {
67391     try {
67392       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
67393     } catch (std::out_of_range& e) {
67394       {
67395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67396       };
67397     } catch (std::exception& e) {
67398       {
67399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67400       };
67401     } catch (Dali::DaliException e) {
67402       {
67403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67404       };
67405     } catch (...) {
67406       {
67407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67408       };
67409     }
67410   }
67411
67412   jresult = (void *)result;
67413   return jresult;
67414 }
67415
67416
67417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
67418   void * jresult ;
67419   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67420   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67421   Dali::Toolkit::ScrollBar *result = 0 ;
67422
67423   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67424   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67425   if (!arg2) {
67426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67427     return 0;
67428   }
67429   {
67430     try {
67431       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67432     } catch (std::out_of_range& e) {
67433       {
67434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67435       };
67436     } catch (std::exception& e) {
67437       {
67438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67439       };
67440     } catch (Dali::DaliException e) {
67441       {
67442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67443       };
67444     } catch (...) {
67445       {
67446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67447       };
67448     }
67449   }
67450
67451   jresult = (void *)result;
67452   return jresult;
67453 }
67454
67455
67456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67457   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67458
67459   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67460   {
67461     try {
67462       delete arg1;
67463     } catch (std::out_of_range& e) {
67464       {
67465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67466       };
67467     } catch (std::exception& e) {
67468       {
67469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67470       };
67471     } catch (Dali::DaliException e) {
67472       {
67473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67474       };
67475     } catch (...) {
67476       {
67477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67478       };
67479     }
67480   }
67481
67482 }
67483
67484
67485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67486   void * jresult ;
67487   Dali::Toolkit::ScrollBar::Direction arg1 ;
67488   Dali::Toolkit::ScrollBar result;
67489
67490   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67491   {
67492     try {
67493       result = Dali::Toolkit::ScrollBar::New(arg1);
67494     } catch (std::out_of_range& e) {
67495       {
67496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67497       };
67498     } catch (std::exception& e) {
67499       {
67500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67501       };
67502     } catch (Dali::DaliException e) {
67503       {
67504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67505       };
67506     } catch (...) {
67507       {
67508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67509       };
67510     }
67511   }
67512
67513   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67514   return jresult;
67515 }
67516
67517
67518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67519   void * jresult ;
67520   Dali::Toolkit::ScrollBar result;
67521
67522   {
67523     try {
67524       result = Dali::Toolkit::ScrollBar::New();
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 = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67545   return jresult;
67546 }
67547
67548
67549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67550   void * jresult ;
67551   Dali::BaseHandle arg1 ;
67552   Dali::BaseHandle *argp1 ;
67553   Dali::Toolkit::ScrollBar result;
67554
67555   argp1 = (Dali::BaseHandle *)jarg1;
67556   if (!argp1) {
67557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67558     return 0;
67559   }
67560   arg1 = *argp1;
67561   {
67562     try {
67563       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67564     } catch (std::out_of_range& e) {
67565       {
67566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67567       };
67568     } catch (std::exception& e) {
67569       {
67570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67571       };
67572     } catch (Dali::DaliException e) {
67573       {
67574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67575       };
67576     } catch (...) {
67577       {
67578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67579       };
67580     }
67581   }
67582
67583   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67584   return jresult;
67585 }
67586
67587
67588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67589   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67590   Dali::Handle arg2 ;
67591   Dali::Property::Index arg3 ;
67592   Dali::Property::Index arg4 ;
67593   Dali::Property::Index arg5 ;
67594   Dali::Property::Index arg6 ;
67595   Dali::Handle *argp2 ;
67596
67597   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67598   argp2 = (Dali::Handle *)jarg2;
67599   if (!argp2) {
67600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67601     return ;
67602   }
67603   arg2 = *argp2;
67604   arg3 = (Dali::Property::Index)jarg3;
67605   arg4 = (Dali::Property::Index)jarg4;
67606   arg5 = (Dali::Property::Index)jarg5;
67607   arg6 = (Dali::Property::Index)jarg6;
67608   {
67609     try {
67610       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67611     } catch (std::out_of_range& e) {
67612       {
67613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67614       };
67615     } catch (std::exception& e) {
67616       {
67617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67618       };
67619     } catch (Dali::DaliException e) {
67620       {
67621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67622       };
67623     } catch (...) {
67624       {
67625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67626       };
67627     }
67628   }
67629
67630 }
67631
67632
67633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67634   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67635   Dali::Actor arg2 ;
67636   Dali::Actor *argp2 ;
67637
67638   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67639   argp2 = (Dali::Actor *)jarg2;
67640   if (!argp2) {
67641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67642     return ;
67643   }
67644   arg2 = *argp2;
67645   {
67646     try {
67647       (arg1)->SetScrollIndicator(arg2);
67648     } catch (std::out_of_range& e) {
67649       {
67650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67651       };
67652     } catch (std::exception& e) {
67653       {
67654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67655       };
67656     } catch (Dali::DaliException e) {
67657       {
67658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67659       };
67660     } catch (...) {
67661       {
67662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67663       };
67664     }
67665   }
67666
67667 }
67668
67669
67670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
67671   void * jresult ;
67672   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67673   Dali::Actor result;
67674
67675   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67676   {
67677     try {
67678       result = (arg1)->GetScrollIndicator();
67679     } catch (std::out_of_range& e) {
67680       {
67681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67682       };
67683     } catch (std::exception& e) {
67684       {
67685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67686       };
67687     } catch (Dali::DaliException e) {
67688       {
67689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67690       };
67691     } catch (...) {
67692       {
67693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67694       };
67695     }
67696   }
67697
67698   jresult = new Dali::Actor((const Dali::Actor &)result);
67699   return jresult;
67700 }
67701
67702
67703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
67704   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67705   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
67706
67707   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67708   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
67709   if (!arg2) {
67710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
67711     return ;
67712   }
67713   {
67714     try {
67715       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
67716     } catch (std::out_of_range& e) {
67717       {
67718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67719       };
67720     } catch (std::exception& e) {
67721       {
67722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67723       };
67724     } catch (Dali::DaliException e) {
67725       {
67726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67727       };
67728     } catch (...) {
67729       {
67730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67731       };
67732     }
67733   }
67734
67735 }
67736
67737
67738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
67739   void * jresult ;
67740   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67741
67742   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67743   {
67744     try {
67745       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()));
67746     } catch (std::out_of_range& e) {
67747       {
67748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67749       };
67750     } catch (std::exception& e) {
67751       {
67752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67753       };
67754     } catch (...) {
67755       {
67756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67757       };
67758     }
67759   }
67760   return jresult;
67761 }
67762
67763
67764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
67765   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67766   Dali::Toolkit::ScrollBar::Direction arg2 ;
67767
67768   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67769   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
67770   {
67771     try {
67772       (arg1)->SetScrollDirection(arg2);
67773     } catch (std::out_of_range& e) {
67774       {
67775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67776       };
67777     } catch (std::exception& e) {
67778       {
67779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67780       };
67781     } catch (Dali::DaliException e) {
67782       {
67783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67784       };
67785     } catch (...) {
67786       {
67787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67788       };
67789     }
67790   }
67791
67792 }
67793
67794
67795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
67796   int jresult ;
67797   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67798   Dali::Toolkit::ScrollBar::Direction result;
67799
67800   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67801   {
67802     try {
67803       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
67804     } catch (std::out_of_range& e) {
67805       {
67806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67807       };
67808     } catch (std::exception& e) {
67809       {
67810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67811       };
67812     } catch (Dali::DaliException e) {
67813       {
67814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67815       };
67816     } catch (...) {
67817       {
67818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67819       };
67820     }
67821   }
67822
67823   jresult = (int)result;
67824   return jresult;
67825 }
67826
67827
67828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
67829   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67830   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
67831
67832   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67833   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
67834   {
67835     try {
67836       (arg1)->SetIndicatorHeightPolicy(arg2);
67837     } catch (std::out_of_range& e) {
67838       {
67839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67840       };
67841     } catch (std::exception& e) {
67842       {
67843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67844       };
67845     } catch (Dali::DaliException e) {
67846       {
67847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67848       };
67849     } catch (...) {
67850       {
67851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67852       };
67853     }
67854   }
67855
67856 }
67857
67858
67859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
67860   int jresult ;
67861   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67862   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
67863
67864   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67865   {
67866     try {
67867       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
67868     } catch (std::out_of_range& e) {
67869       {
67870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67871       };
67872     } catch (std::exception& e) {
67873       {
67874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67875       };
67876     } catch (Dali::DaliException e) {
67877       {
67878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67879       };
67880     } catch (...) {
67881       {
67882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67883       };
67884     }
67885   }
67886
67887   jresult = (int)result;
67888   return jresult;
67889 }
67890
67891
67892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
67893   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67894   float arg2 ;
67895
67896   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67897   arg2 = (float)jarg2;
67898   {
67899     try {
67900       (arg1)->SetIndicatorFixedHeight(arg2);
67901     } catch (std::out_of_range& e) {
67902       {
67903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67904       };
67905     } catch (std::exception& e) {
67906       {
67907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67908       };
67909     } catch (Dali::DaliException e) {
67910       {
67911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67912       };
67913     } catch (...) {
67914       {
67915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67916       };
67917     }
67918   }
67919
67920 }
67921
67922
67923 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
67924   float jresult ;
67925   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67926   float result;
67927
67928   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67929   {
67930     try {
67931       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
67932     } catch (std::out_of_range& e) {
67933       {
67934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67935       };
67936     } catch (std::exception& e) {
67937       {
67938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67939       };
67940     } catch (Dali::DaliException e) {
67941       {
67942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67943       };
67944     } catch (...) {
67945       {
67946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67947       };
67948     }
67949   }
67950
67951   jresult = result;
67952   return jresult;
67953 }
67954
67955
67956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
67957   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67958   float arg2 ;
67959
67960   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67961   arg2 = (float)jarg2;
67962   {
67963     try {
67964       (arg1)->SetIndicatorShowDuration(arg2);
67965     } catch (std::out_of_range& e) {
67966       {
67967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67968       };
67969     } catch (std::exception& e) {
67970       {
67971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67972       };
67973     } catch (Dali::DaliException e) {
67974       {
67975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67976       };
67977     } catch (...) {
67978       {
67979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67980       };
67981     }
67982   }
67983
67984 }
67985
67986
67987 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
67988   float jresult ;
67989   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67990   float result;
67991
67992   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67993   {
67994     try {
67995       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
67996     } catch (std::out_of_range& e) {
67997       {
67998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67999       };
68000     } catch (std::exception& e) {
68001       {
68002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68003       };
68004     } catch (Dali::DaliException e) {
68005       {
68006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68007       };
68008     } catch (...) {
68009       {
68010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68011       };
68012     }
68013   }
68014
68015   jresult = result;
68016   return jresult;
68017 }
68018
68019
68020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68021   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68022   float arg2 ;
68023
68024   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68025   arg2 = (float)jarg2;
68026   {
68027     try {
68028       (arg1)->SetIndicatorHideDuration(arg2);
68029     } catch (std::out_of_range& e) {
68030       {
68031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68032       };
68033     } catch (std::exception& e) {
68034       {
68035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68036       };
68037     } catch (Dali::DaliException e) {
68038       {
68039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68040       };
68041     } catch (...) {
68042       {
68043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68044       };
68045     }
68046   }
68047
68048 }
68049
68050
68051 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68052   float jresult ;
68053   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68054   float result;
68055
68056   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68057   {
68058     try {
68059       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68060     } catch (std::out_of_range& e) {
68061       {
68062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68063       };
68064     } catch (std::exception& e) {
68065       {
68066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68067       };
68068     } catch (Dali::DaliException e) {
68069       {
68070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68071       };
68072     } catch (...) {
68073       {
68074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68075       };
68076     }
68077   }
68078
68079   jresult = result;
68080   return jresult;
68081 }
68082
68083
68084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68085   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68086
68087   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68088   {
68089     try {
68090       (arg1)->ShowIndicator();
68091     } catch (std::out_of_range& e) {
68092       {
68093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68094       };
68095     } catch (std::exception& e) {
68096       {
68097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68098       };
68099     } catch (Dali::DaliException e) {
68100       {
68101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68102       };
68103     } catch (...) {
68104       {
68105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68106       };
68107     }
68108   }
68109
68110 }
68111
68112
68113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68114   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68115
68116   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68117   {
68118     try {
68119       (arg1)->HideIndicator();
68120     } catch (std::out_of_range& e) {
68121       {
68122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68123       };
68124     } catch (std::exception& e) {
68125       {
68126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68127       };
68128     } catch (Dali::DaliException e) {
68129       {
68130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68131       };
68132     } catch (...) {
68133       {
68134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68135       };
68136     }
68137   }
68138
68139 }
68140
68141
68142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68143   void * jresult ;
68144   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68145   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68146
68147   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68148   {
68149     try {
68150       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68151     } catch (std::out_of_range& e) {
68152       {
68153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68154       };
68155     } catch (std::exception& e) {
68156       {
68157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68158       };
68159     } catch (Dali::DaliException e) {
68160       {
68161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68162       };
68163     } catch (...) {
68164       {
68165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68166       };
68167     }
68168   }
68169
68170   jresult = (void *)result;
68171   return jresult;
68172 }
68173
68174
68175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68176   void * jresult ;
68177   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68178   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68179
68180   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68181   {
68182     try {
68183       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68184     } catch (std::out_of_range& e) {
68185       {
68186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68187       };
68188     } catch (std::exception& e) {
68189       {
68190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68191       };
68192     } catch (Dali::DaliException e) {
68193       {
68194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68195       };
68196     } catch (...) {
68197       {
68198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68199       };
68200     }
68201   }
68202
68203   jresult = (void *)result;
68204   return jresult;
68205 }
68206
68207
68208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68209   int jresult ;
68210   int result;
68211
68212   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68213   jresult = (int)result;
68214   return jresult;
68215 }
68216
68217
68218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68219   int jresult ;
68220   int result;
68221
68222   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68223   jresult = (int)result;
68224   return jresult;
68225 }
68226
68227
68228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68229   int jresult ;
68230   int result;
68231
68232   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68233   jresult = (int)result;
68234   return jresult;
68235 }
68236
68237
68238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68239   int jresult ;
68240   int result;
68241
68242   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68243   jresult = (int)result;
68244   return jresult;
68245 }
68246
68247
68248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68249   int jresult ;
68250   int result;
68251
68252   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68253   jresult = (int)result;
68254   return jresult;
68255 }
68256
68257
68258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68259   int jresult ;
68260   int result;
68261
68262   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68263   jresult = (int)result;
68264   return jresult;
68265 }
68266
68267
68268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68269   int jresult ;
68270   int result;
68271
68272   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68273   jresult = (int)result;
68274   return jresult;
68275 }
68276
68277
68278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68279   int jresult ;
68280   int result;
68281
68282   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68283   jresult = (int)result;
68284   return jresult;
68285 }
68286
68287
68288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68289   int jresult ;
68290   int result;
68291
68292   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68293   jresult = (int)result;
68294   return jresult;
68295 }
68296
68297
68298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68299   int jresult ;
68300   int result;
68301
68302   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68303   jresult = (int)result;
68304   return jresult;
68305 }
68306
68307
68308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68309   int jresult ;
68310   int result;
68311
68312   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68313   jresult = (int)result;
68314   return jresult;
68315 }
68316
68317
68318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68319   int jresult ;
68320   int result;
68321
68322   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68323   jresult = (int)result;
68324   return jresult;
68325 }
68326
68327
68328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68329   int jresult ;
68330   int result;
68331
68332   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68333   jresult = (int)result;
68334   return jresult;
68335 }
68336
68337
68338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68339   int jresult ;
68340   int result;
68341
68342   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68343   jresult = (int)result;
68344   return jresult;
68345 }
68346
68347
68348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
68349   void * jresult ;
68350   Dali::Toolkit::Scrollable::Property *result = 0 ;
68351
68352   {
68353     try {
68354       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68355     } catch (std::out_of_range& e) {
68356       {
68357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68358       };
68359     } catch (std::exception& e) {
68360       {
68361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68362       };
68363     } catch (Dali::DaliException e) {
68364       {
68365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68366       };
68367     } catch (...) {
68368       {
68369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68370       };
68371     }
68372   }
68373
68374   jresult = (void *)result;
68375   return jresult;
68376 }
68377
68378
68379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
68380   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68381
68382   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68383   {
68384     try {
68385       delete arg1;
68386     } catch (std::out_of_range& e) {
68387       {
68388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68389       };
68390     } catch (std::exception& e) {
68391       {
68392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68393       };
68394     } catch (Dali::DaliException e) {
68395       {
68396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68397       };
68398     } catch (...) {
68399       {
68400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68401       };
68402     }
68403   }
68404
68405 }
68406
68407
68408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68409   void * jresult ;
68410   Dali::Toolkit::Scrollable *result = 0 ;
68411
68412   {
68413     try {
68414       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68415     } catch (std::out_of_range& e) {
68416       {
68417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68418       };
68419     } catch (std::exception& e) {
68420       {
68421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68422       };
68423     } catch (Dali::DaliException e) {
68424       {
68425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68426       };
68427     } catch (...) {
68428       {
68429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68430       };
68431     }
68432   }
68433
68434   jresult = (void *)result;
68435   return jresult;
68436 }
68437
68438
68439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68440   void * jresult ;
68441   Dali::Toolkit::Scrollable *arg1 = 0 ;
68442   Dali::Toolkit::Scrollable *result = 0 ;
68443
68444   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68445   if (!arg1) {
68446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68447     return 0;
68448   }
68449   {
68450     try {
68451       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68452     } catch (std::out_of_range& e) {
68453       {
68454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68455       };
68456     } catch (std::exception& e) {
68457       {
68458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68459       };
68460     } catch (Dali::DaliException e) {
68461       {
68462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68463       };
68464     } catch (...) {
68465       {
68466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68467       };
68468     }
68469   }
68470
68471   jresult = (void *)result;
68472   return jresult;
68473 }
68474
68475
68476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
68477   void * jresult ;
68478   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68479   Dali::Toolkit::Scrollable *arg2 = 0 ;
68480   Dali::Toolkit::Scrollable *result = 0 ;
68481
68482   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68483   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
68484   if (!arg2) {
68485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68486     return 0;
68487   }
68488   {
68489     try {
68490       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
68491     } catch (std::out_of_range& e) {
68492       {
68493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68494       };
68495     } catch (std::exception& e) {
68496       {
68497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68498       };
68499     } catch (Dali::DaliException e) {
68500       {
68501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68502       };
68503     } catch (...) {
68504       {
68505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68506       };
68507     }
68508   }
68509
68510   jresult = (void *)result;
68511   return jresult;
68512 }
68513
68514
68515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
68516   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68517
68518   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68519   {
68520     try {
68521       delete arg1;
68522     } catch (std::out_of_range& e) {
68523       {
68524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68525       };
68526     } catch (std::exception& e) {
68527       {
68528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68529       };
68530     } catch (Dali::DaliException e) {
68531       {
68532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68533       };
68534     } catch (...) {
68535       {
68536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68537       };
68538     }
68539   }
68540
68541 }
68542
68543
68544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
68545   void * jresult ;
68546   Dali::BaseHandle arg1 ;
68547   Dali::BaseHandle *argp1 ;
68548   Dali::Toolkit::Scrollable result;
68549
68550   argp1 = (Dali::BaseHandle *)jarg1;
68551   if (!argp1) {
68552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68553     return 0;
68554   }
68555   arg1 = *argp1;
68556   {
68557     try {
68558       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68559     } catch (std::out_of_range& e) {
68560       {
68561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68562       };
68563     } catch (std::exception& e) {
68564       {
68565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68566       };
68567     } catch (Dali::DaliException e) {
68568       {
68569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68570       };
68571     } catch (...) {
68572       {
68573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68574       };
68575     }
68576   }
68577
68578   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68579   return jresult;
68580 }
68581
68582
68583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68584   unsigned int jresult ;
68585   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68586   bool result;
68587
68588   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68589   {
68590     try {
68591       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68592     } catch (std::out_of_range& e) {
68593       {
68594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68595       };
68596     } catch (std::exception& e) {
68597       {
68598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68599       };
68600     } catch (Dali::DaliException e) {
68601       {
68602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68603       };
68604     } catch (...) {
68605       {
68606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68607       };
68608     }
68609   }
68610
68611   jresult = result;
68612   return jresult;
68613 }
68614
68615
68616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68617   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68618   bool arg2 ;
68619
68620   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68621   arg2 = jarg2 ? true : false;
68622   {
68623     try {
68624       (arg1)->SetOvershootEnabled(arg2);
68625     } catch (std::out_of_range& e) {
68626       {
68627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68628       };
68629     } catch (std::exception& e) {
68630       {
68631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68632       };
68633     } catch (Dali::DaliException e) {
68634       {
68635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68636       };
68637     } catch (...) {
68638       {
68639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68640       };
68641     }
68642   }
68643
68644 }
68645
68646
68647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68648   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68649   Dali::Vector4 *arg2 = 0 ;
68650
68651   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68652   arg2 = (Dali::Vector4 *)jarg2;
68653   if (!arg2) {
68654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68655     return ;
68656   }
68657   {
68658     try {
68659       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68660     } catch (std::out_of_range& e) {
68661       {
68662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68663       };
68664     } catch (std::exception& e) {
68665       {
68666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68667       };
68668     } catch (Dali::DaliException e) {
68669       {
68670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68671       };
68672     } catch (...) {
68673       {
68674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68675       };
68676     }
68677   }
68678
68679 }
68680
68681
68682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
68683   void * jresult ;
68684   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68685   Dali::Vector4 result;
68686
68687   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68688   {
68689     try {
68690       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68691     } catch (std::out_of_range& e) {
68692       {
68693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68694       };
68695     } catch (std::exception& e) {
68696       {
68697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68698       };
68699     } catch (Dali::DaliException e) {
68700       {
68701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68702       };
68703     } catch (...) {
68704       {
68705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68706       };
68707     }
68708   }
68709
68710   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68711   return jresult;
68712 }
68713
68714
68715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68716   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68717   float arg2 ;
68718
68719   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68720   arg2 = (float)jarg2;
68721   {
68722     try {
68723       (arg1)->SetOvershootAnimationSpeed(arg2);
68724     } catch (std::out_of_range& e) {
68725       {
68726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68727       };
68728     } catch (std::exception& e) {
68729       {
68730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68731       };
68732     } catch (Dali::DaliException e) {
68733       {
68734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68735       };
68736     } catch (...) {
68737       {
68738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68739       };
68740     }
68741   }
68742
68743 }
68744
68745
68746 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
68747   float jresult ;
68748   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68749   float result;
68750
68751   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68752   {
68753     try {
68754       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
68755     } catch (std::out_of_range& e) {
68756       {
68757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68758       };
68759     } catch (std::exception& e) {
68760       {
68761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68762       };
68763     } catch (Dali::DaliException e) {
68764       {
68765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68766       };
68767     } catch (...) {
68768       {
68769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68770       };
68771     }
68772   }
68773
68774   jresult = result;
68775   return jresult;
68776 }
68777
68778
68779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
68780   void * jresult ;
68781   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68782   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
68783
68784   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68785   {
68786     try {
68787       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
68788     } catch (std::out_of_range& e) {
68789       {
68790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68791       };
68792     } catch (std::exception& e) {
68793       {
68794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68795       };
68796     } catch (Dali::DaliException e) {
68797       {
68798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68799       };
68800     } catch (...) {
68801       {
68802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68803       };
68804     }
68805   }
68806
68807   jresult = (void *)result;
68808   return jresult;
68809 }
68810
68811
68812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
68813   void * jresult ;
68814   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68815   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
68816
68817   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68818   {
68819     try {
68820       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
68821     } catch (std::out_of_range& e) {
68822       {
68823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68824       };
68825     } catch (std::exception& e) {
68826       {
68827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68828       };
68829     } catch (Dali::DaliException e) {
68830       {
68831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68832       };
68833     } catch (...) {
68834       {
68835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68836       };
68837     }
68838   }
68839
68840   jresult = (void *)result;
68841   return jresult;
68842 }
68843
68844
68845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
68846   void * jresult ;
68847   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68848   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
68849
68850   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68851   {
68852     try {
68853       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
68854     } catch (std::out_of_range& e) {
68855       {
68856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68857       };
68858     } catch (std::exception& e) {
68859       {
68860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68861       };
68862     } catch (Dali::DaliException e) {
68863       {
68864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68865       };
68866     } catch (...) {
68867       {
68868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68869       };
68870     }
68871   }
68872
68873   jresult = (void *)result;
68874   return jresult;
68875 }
68876
68877
68878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
68879   unsigned int jresult ;
68880   Dali::Toolkit::ControlOrientation::Type arg1 ;
68881   bool result;
68882
68883   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68884   {
68885     try {
68886       result = (bool)Dali::Toolkit::IsVertical(arg1);
68887     } catch (std::out_of_range& e) {
68888       {
68889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68890       };
68891     } catch (std::exception& e) {
68892       {
68893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68894       };
68895     } catch (Dali::DaliException e) {
68896       {
68897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68898       };
68899     } catch (...) {
68900       {
68901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68902       };
68903     }
68904   }
68905
68906   jresult = result;
68907   return jresult;
68908 }
68909
68910
68911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
68912   unsigned int jresult ;
68913   Dali::Toolkit::ControlOrientation::Type arg1 ;
68914   bool result;
68915
68916   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68917   {
68918     try {
68919       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
68920     } catch (std::out_of_range& e) {
68921       {
68922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68923       };
68924     } catch (std::exception& e) {
68925       {
68926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68927       };
68928     } catch (Dali::DaliException e) {
68929       {
68930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68931       };
68932     } catch (...) {
68933       {
68934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68935       };
68936     }
68937   }
68938
68939   jresult = result;
68940   return jresult;
68941 }
68942
68943
68944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
68945   void * jresult ;
68946   unsigned int arg1 ;
68947   unsigned int arg2 ;
68948   Dali::Toolkit::ItemRange *result = 0 ;
68949
68950   arg1 = (unsigned int)jarg1;
68951   arg2 = (unsigned int)jarg2;
68952   {
68953     try {
68954       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
68955     } catch (std::out_of_range& e) {
68956       {
68957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68958       };
68959     } catch (std::exception& e) {
68960       {
68961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68962       };
68963     } catch (Dali::DaliException e) {
68964       {
68965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68966       };
68967     } catch (...) {
68968       {
68969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68970       };
68971     }
68972   }
68973
68974   jresult = (void *)result;
68975   return jresult;
68976 }
68977
68978
68979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
68980   void * jresult ;
68981   Dali::Toolkit::ItemRange *arg1 = 0 ;
68982   Dali::Toolkit::ItemRange *result = 0 ;
68983
68984   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68985   if (!arg1) {
68986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68987     return 0;
68988   }
68989   {
68990     try {
68991       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
68992     } catch (std::out_of_range& e) {
68993       {
68994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68995       };
68996     } catch (std::exception& e) {
68997       {
68998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68999       };
69000     } catch (Dali::DaliException e) {
69001       {
69002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69003       };
69004     } catch (...) {
69005       {
69006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69007       };
69008     }
69009   }
69010
69011   jresult = (void *)result;
69012   return jresult;
69013 }
69014
69015
69016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69017   void * jresult ;
69018   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69019   Dali::Toolkit::ItemRange *arg2 = 0 ;
69020   Dali::Toolkit::ItemRange *result = 0 ;
69021
69022   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69023   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69024   if (!arg2) {
69025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69026     return 0;
69027   }
69028   {
69029     try {
69030       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69031     } catch (std::out_of_range& e) {
69032       {
69033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69034       };
69035     } catch (std::exception& e) {
69036       {
69037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69038       };
69039     } catch (Dali::DaliException e) {
69040       {
69041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69042       };
69043     } catch (...) {
69044       {
69045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69046       };
69047     }
69048   }
69049
69050   jresult = (void *)result;
69051   return jresult;
69052 }
69053
69054
69055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69056   unsigned int jresult ;
69057   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69058   unsigned int arg2 ;
69059   bool result;
69060
69061   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69062   arg2 = (unsigned int)jarg2;
69063   {
69064     try {
69065       result = (bool)(arg1)->Within(arg2);
69066     } catch (std::out_of_range& e) {
69067       {
69068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69069       };
69070     } catch (std::exception& e) {
69071       {
69072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69073       };
69074     } catch (Dali::DaliException e) {
69075       {
69076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69077       };
69078     } catch (...) {
69079       {
69080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69081       };
69082     }
69083   }
69084
69085   jresult = result;
69086   return jresult;
69087 }
69088
69089
69090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69091   void * jresult ;
69092   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69093   Dali::Toolkit::ItemRange *arg2 = 0 ;
69094   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69095
69096   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69097   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69098   if (!arg2) {
69099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69100     return 0;
69101   }
69102   {
69103     try {
69104       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69105     } catch (std::out_of_range& e) {
69106       {
69107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69108       };
69109     } catch (std::exception& e) {
69110       {
69111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69112       };
69113     } catch (Dali::DaliException e) {
69114       {
69115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69116       };
69117     } catch (...) {
69118       {
69119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69120       };
69121     }
69122   }
69123
69124   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69125   return jresult;
69126 }
69127
69128
69129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69130   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69131   unsigned int arg2 ;
69132
69133   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69134   arg2 = (unsigned int)jarg2;
69135   if (arg1) (arg1)->begin = arg2;
69136 }
69137
69138
69139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
69140   unsigned int jresult ;
69141   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69142   unsigned int result;
69143
69144   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69145   result = (unsigned int) ((arg1)->begin);
69146   jresult = result;
69147   return jresult;
69148 }
69149
69150
69151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69152   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69153   unsigned int arg2 ;
69154
69155   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69156   arg2 = (unsigned int)jarg2;
69157   if (arg1) (arg1)->end = arg2;
69158 }
69159
69160
69161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69162   unsigned int jresult ;
69163   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69164   unsigned int result;
69165
69166   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69167   result = (unsigned int) ((arg1)->end);
69168   jresult = result;
69169   return jresult;
69170 }
69171
69172
69173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69174   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69175
69176   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69177   {
69178     try {
69179       delete arg1;
69180     } catch (std::out_of_range& e) {
69181       {
69182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69183       };
69184     } catch (std::exception& e) {
69185       {
69186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69187       };
69188     } catch (Dali::DaliException e) {
69189       {
69190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69191       };
69192     } catch (...) {
69193       {
69194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69195       };
69196     }
69197   }
69198
69199 }
69200
69201
69202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69203   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69204
69205   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69206   {
69207     try {
69208       delete arg1;
69209     } catch (std::out_of_range& e) {
69210       {
69211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69212       };
69213     } catch (std::exception& e) {
69214       {
69215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69216       };
69217     } catch (Dali::DaliException e) {
69218       {
69219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69220       };
69221     } catch (...) {
69222       {
69223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69224       };
69225     }
69226   }
69227
69228 }
69229
69230
69231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69232   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69233   Dali::Toolkit::ControlOrientation::Type arg2 ;
69234
69235   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69236   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69237   {
69238     try {
69239       (arg1)->SetOrientation(arg2);
69240     } catch (std::out_of_range& e) {
69241       {
69242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69243       };
69244     } catch (std::exception& e) {
69245       {
69246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69247       };
69248     } catch (Dali::DaliException e) {
69249       {
69250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69251       };
69252     } catch (...) {
69253       {
69254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69255       };
69256     }
69257   }
69258
69259 }
69260
69261
69262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69263   int jresult ;
69264   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69265   Dali::Toolkit::ControlOrientation::Type result;
69266
69267   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69268   {
69269     try {
69270       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69271     } catch (std::out_of_range& e) {
69272       {
69273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69274       };
69275     } catch (std::exception& e) {
69276       {
69277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69278       };
69279     } catch (Dali::DaliException e) {
69280       {
69281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69282       };
69283     } catch (...) {
69284       {
69285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69286       };
69287     }
69288   }
69289
69290   jresult = (int)result;
69291   return jresult;
69292 }
69293
69294
69295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69296   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69297   Dali::Property::Map *arg2 = 0 ;
69298
69299   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69300   arg2 = (Dali::Property::Map *)jarg2;
69301   if (!arg2) {
69302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69303     return ;
69304   }
69305   {
69306     try {
69307       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69308     } catch (std::out_of_range& e) {
69309       {
69310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69311       };
69312     } catch (std::exception& e) {
69313       {
69314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69315       };
69316     } catch (Dali::DaliException e) {
69317       {
69318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69319       };
69320     } catch (...) {
69321       {
69322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69323       };
69324     }
69325   }
69326
69327 }
69328
69329
69330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69331   void * jresult ;
69332   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69333   Dali::Property::Map result;
69334
69335   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69336   {
69337     try {
69338       result = (arg1)->GetLayoutProperties();
69339     } catch (std::out_of_range& e) {
69340       {
69341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69342       };
69343     } catch (std::exception& e) {
69344       {
69345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69346       };
69347     } catch (Dali::DaliException e) {
69348       {
69349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69350       };
69351     } catch (...) {
69352       {
69353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69354       };
69355     }
69356   }
69357
69358   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69359   return jresult;
69360 }
69361
69362
69363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69364   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69365   unsigned int arg2 ;
69366   Dali::Vector3 *arg3 = 0 ;
69367   Dali::Vector3 *arg4 = 0 ;
69368
69369   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69370   arg2 = (unsigned int)jarg2;
69371   arg3 = (Dali::Vector3 *)jarg3;
69372   if (!arg3) {
69373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69374     return ;
69375   }
69376   arg4 = (Dali::Vector3 *)jarg4;
69377   if (!arg4) {
69378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69379     return ;
69380   }
69381   {
69382     try {
69383       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69384     } catch (std::out_of_range& e) {
69385       {
69386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69387       };
69388     } catch (std::exception& e) {
69389       {
69390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69391       };
69392     } catch (Dali::DaliException e) {
69393       {
69394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69395       };
69396     } catch (...) {
69397       {
69398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69399       };
69400     }
69401   }
69402
69403 }
69404
69405
69406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69407   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69408   Dali::Vector3 *arg2 = 0 ;
69409
69410   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69411   arg2 = (Dali::Vector3 *)jarg2;
69412   if (!arg2) {
69413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69414     return ;
69415   }
69416   {
69417     try {
69418       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69419     } catch (std::out_of_range& e) {
69420       {
69421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69422       };
69423     } catch (std::exception& e) {
69424       {
69425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69426       };
69427     } catch (Dali::DaliException e) {
69428       {
69429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69430       };
69431     } catch (...) {
69432       {
69433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69434       };
69435     }
69436   }
69437
69438 }
69439
69440
69441 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69442   float jresult ;
69443   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69444   unsigned int arg2 ;
69445   Dali::Vector3 arg3 ;
69446   Dali::Vector3 *argp3 ;
69447   float result;
69448
69449   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69450   arg2 = (unsigned int)jarg2;
69451   argp3 = (Dali::Vector3 *)jarg3;
69452   if (!argp3) {
69453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69454     return 0;
69455   }
69456   arg3 = *argp3;
69457   {
69458     try {
69459       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69460     } catch (std::out_of_range& e) {
69461       {
69462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69463       };
69464     } catch (std::exception& e) {
69465       {
69466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69467       };
69468     } catch (Dali::DaliException e) {
69469       {
69470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69471       };
69472     } catch (...) {
69473       {
69474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69475       };
69476     }
69477   }
69478
69479   jresult = result;
69480   return jresult;
69481 }
69482
69483
69484 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69485   float jresult ;
69486   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69487   float arg2 ;
69488   float result;
69489
69490   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69491   arg2 = (float)jarg2;
69492   {
69493     try {
69494       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69495     } catch (std::out_of_range& e) {
69496       {
69497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69498       };
69499     } catch (std::exception& e) {
69500       {
69501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69502       };
69503     } catch (Dali::DaliException e) {
69504       {
69505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69506       };
69507     } catch (...) {
69508       {
69509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69510       };
69511     }
69512   }
69513
69514   jresult = result;
69515   return jresult;
69516 }
69517
69518
69519 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
69520   float jresult ;
69521   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69522   unsigned int arg2 ;
69523   float result;
69524
69525   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69526   arg2 = (unsigned int)jarg2;
69527   {
69528     try {
69529       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
69530     } catch (std::out_of_range& e) {
69531       {
69532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69533       };
69534     } catch (std::exception& e) {
69535       {
69536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69537       };
69538     } catch (Dali::DaliException e) {
69539       {
69540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69541       };
69542     } catch (...) {
69543       {
69544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69545       };
69546     }
69547   }
69548
69549   jresult = result;
69550   return jresult;
69551 }
69552
69553
69554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
69555   void * jresult ;
69556   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69557   float arg2 ;
69558   Dali::Vector3 arg3 ;
69559   Dali::Vector3 *argp3 ;
69560   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69561
69562   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69563   arg2 = (float)jarg2;
69564   argp3 = (Dali::Vector3 *)jarg3;
69565   if (!argp3) {
69566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69567     return 0;
69568   }
69569   arg3 = *argp3;
69570   {
69571     try {
69572       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69573     } catch (std::out_of_range& e) {
69574       {
69575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69576       };
69577     } catch (std::exception& e) {
69578       {
69579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69580       };
69581     } catch (Dali::DaliException e) {
69582       {
69583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69584       };
69585     } catch (...) {
69586       {
69587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69588       };
69589     }
69590   }
69591
69592   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69593   return jresult;
69594 }
69595
69596
69597 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69598   float jresult ;
69599   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69600   int arg2 ;
69601   float arg3 ;
69602   Dali::Vector3 *arg4 = 0 ;
69603   float result;
69604
69605   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69606   arg2 = (int)jarg2;
69607   arg3 = (float)jarg3;
69608   arg4 = (Dali::Vector3 *)jarg4;
69609   if (!arg4) {
69610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69611     return 0;
69612   }
69613   {
69614     try {
69615       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69616     } catch (std::out_of_range& e) {
69617       {
69618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69619       };
69620     } catch (std::exception& e) {
69621       {
69622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69623       };
69624     } catch (Dali::DaliException e) {
69625       {
69626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69627       };
69628     } catch (...) {
69629       {
69630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69631       };
69632     }
69633   }
69634
69635   jresult = result;
69636   return jresult;
69637 }
69638
69639
69640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
69641   unsigned int jresult ;
69642   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69643   Dali::Vector3 arg2 ;
69644   Dali::Vector3 *argp2 ;
69645   unsigned int result;
69646
69647   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69648   argp2 = (Dali::Vector3 *)jarg2;
69649   if (!argp2) {
69650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69651     return 0;
69652   }
69653   arg2 = *argp2;
69654   {
69655     try {
69656       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
69657     } catch (std::out_of_range& e) {
69658       {
69659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69660       };
69661     } catch (std::exception& e) {
69662       {
69663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69664       };
69665     } catch (Dali::DaliException e) {
69666       {
69667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69668       };
69669     } catch (...) {
69670       {
69671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69672       };
69673     }
69674   }
69675
69676   jresult = result;
69677   return jresult;
69678 }
69679
69680
69681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69682   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69683   unsigned int arg2 ;
69684   Dali::Vector3 *arg3 = 0 ;
69685   Dali::Vector3 *arg4 = 0 ;
69686
69687   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69688   arg2 = (unsigned int)jarg2;
69689   arg3 = (Dali::Vector3 *)jarg3;
69690   if (!arg3) {
69691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69692     return ;
69693   }
69694   arg4 = (Dali::Vector3 *)jarg4;
69695   if (!arg4) {
69696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69697     return ;
69698   }
69699   {
69700     try {
69701       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69702     } catch (std::out_of_range& e) {
69703       {
69704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69705       };
69706     } catch (std::exception& e) {
69707       {
69708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69709       };
69710     } catch (Dali::DaliException e) {
69711       {
69712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69713       };
69714     } catch (...) {
69715       {
69716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69717       };
69718     }
69719   }
69720
69721 }
69722
69723
69724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
69725   void * jresult ;
69726   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69727   Dali::Degree result;
69728
69729   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69730   {
69731     try {
69732       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69733     } catch (std::out_of_range& e) {
69734       {
69735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69736       };
69737     } catch (std::exception& e) {
69738       {
69739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69740       };
69741     } catch (Dali::DaliException e) {
69742       {
69743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69744       };
69745     } catch (...) {
69746       {
69747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69748       };
69749     }
69750   }
69751
69752   jresult = new Dali::Degree((const Dali::Degree &)result);
69753   return jresult;
69754 }
69755
69756
69757 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
69758   float jresult ;
69759   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69760   float result;
69761
69762   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69763   {
69764     try {
69765       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
69766     } catch (std::out_of_range& e) {
69767       {
69768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69769       };
69770     } catch (std::exception& e) {
69771       {
69772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69773       };
69774     } catch (Dali::DaliException e) {
69775       {
69776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69777       };
69778     } catch (...) {
69779       {
69780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69781       };
69782     }
69783   }
69784
69785   jresult = result;
69786   return jresult;
69787 }
69788
69789
69790 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
69791   float jresult ;
69792   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69793   float result;
69794
69795   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69796   {
69797     try {
69798       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
69799     } catch (std::out_of_range& e) {
69800       {
69801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69802       };
69803     } catch (std::exception& e) {
69804       {
69805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69806       };
69807     } catch (Dali::DaliException e) {
69808       {
69809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69810       };
69811     } catch (...) {
69812       {
69813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69814       };
69815     }
69816   }
69817
69818   jresult = result;
69819   return jresult;
69820 }
69821
69822
69823 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
69824   float jresult ;
69825   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69826   float result;
69827
69828   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69829   {
69830     try {
69831       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
69832     } catch (std::out_of_range& e) {
69833       {
69834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69835       };
69836     } catch (std::exception& e) {
69837       {
69838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69839       };
69840     } catch (Dali::DaliException e) {
69841       {
69842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69843       };
69844     } catch (...) {
69845       {
69846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69847       };
69848     }
69849   }
69850
69851   jresult = result;
69852   return jresult;
69853 }
69854
69855
69856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
69857   int jresult ;
69858   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69859   int arg2 ;
69860   int arg3 ;
69861   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
69862   bool arg5 ;
69863   int result;
69864
69865   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69866   arg2 = (int)jarg2;
69867   arg3 = (int)jarg3;
69868   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
69869   arg5 = jarg5 ? true : false;
69870   {
69871     try {
69872       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
69873     } catch (std::out_of_range& e) {
69874       {
69875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69876       };
69877     } catch (std::exception& e) {
69878       {
69879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69880       };
69881     } catch (Dali::DaliException e) {
69882       {
69883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69884       };
69885     } catch (...) {
69886       {
69887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69888       };
69889     }
69890   }
69891
69892   jresult = result;
69893   return jresult;
69894 }
69895
69896
69897 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
69898   float jresult ;
69899   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69900   float result;
69901
69902   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69903   {
69904     try {
69905       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
69906     } catch (std::out_of_range& e) {
69907       {
69908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69909       };
69910     } catch (std::exception& e) {
69911       {
69912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69913       };
69914     } catch (Dali::DaliException e) {
69915       {
69916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69917       };
69918     } catch (...) {
69919       {
69920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69921       };
69922     }
69923   }
69924
69925   jresult = result;
69926   return jresult;
69927 }
69928
69929
69930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
69931   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69932   Dali::Actor *arg2 = 0 ;
69933   int arg3 ;
69934   Dali::Vector3 *arg4 = 0 ;
69935   Dali::Actor *arg5 = 0 ;
69936
69937   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69938   arg2 = (Dali::Actor *)jarg2;
69939   if (!arg2) {
69940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
69941     return ;
69942   }
69943   arg3 = (int)jarg3;
69944   arg4 = (Dali::Vector3 *)jarg4;
69945   if (!arg4) {
69946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69947     return ;
69948   }
69949   arg5 = (Dali::Actor *)jarg5;
69950   if (!arg5) {
69951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
69952     return ;
69953   }
69954   {
69955     try {
69956       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
69957     } catch (std::out_of_range& e) {
69958       {
69959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69960       };
69961     } catch (std::exception& e) {
69962       {
69963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69964       };
69965     } catch (Dali::DaliException e) {
69966       {
69967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69968       };
69969     } catch (...) {
69970       {
69971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69972       };
69973     }
69974   }
69975
69976 }
69977
69978
69979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69980   void * jresult ;
69981   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69982   int arg2 ;
69983   float arg3 ;
69984   Dali::Vector3 *arg4 = 0 ;
69985   Dali::Vector3 result;
69986
69987   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69988   arg2 = (int)jarg2;
69989   arg3 = (float)jarg3;
69990   arg4 = (Dali::Vector3 *)jarg4;
69991   if (!arg4) {
69992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69993     return 0;
69994   }
69995   {
69996     try {
69997       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69998     } catch (std::out_of_range& e) {
69999       {
70000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70001       };
70002     } catch (std::exception& e) {
70003       {
70004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70005       };
70006     } catch (Dali::DaliException e) {
70007       {
70008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70009       };
70010     } catch (...) {
70011       {
70012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70013       };
70014     }
70015   }
70016
70017   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70018   return jresult;
70019 }
70020
70021
70022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70023   void * jresult ;
70024   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70025   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70026
70027   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70028   {
70029     try {
70030       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70031     } catch (std::out_of_range& e) {
70032       {
70033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70034       };
70035     } catch (std::exception& e) {
70036       {
70037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70038       };
70039     } catch (Dali::DaliException e) {
70040       {
70041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70042       };
70043     } catch (...) {
70044       {
70045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70046       };
70047     }
70048   }
70049
70050   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70051   return jresult;
70052 }
70053
70054
70055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70056   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70057
70058   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70059   {
70060     try {
70061       delete arg1;
70062     } catch (std::out_of_range& e) {
70063       {
70064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70065       };
70066     } catch (std::exception& e) {
70067       {
70068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70069       };
70070     } catch (Dali::DaliException e) {
70071       {
70072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70073       };
70074     } catch (...) {
70075       {
70076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70077       };
70078     }
70079   }
70080
70081 }
70082
70083
70084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70085   unsigned int jresult ;
70086   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70087   unsigned int result;
70088
70089   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70090   {
70091     try {
70092       result = (unsigned int)(arg1)->GetNumberOfItems();
70093     } catch (std::out_of_range& e) {
70094       {
70095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70096       };
70097     } catch (std::exception& e) {
70098       {
70099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70100       };
70101     } catch (Dali::DaliException e) {
70102       {
70103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70104       };
70105     } catch (...) {
70106       {
70107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70108       };
70109     }
70110   }
70111
70112   jresult = result;
70113   return jresult;
70114 }
70115
70116
70117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70118   void * jresult ;
70119   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70120   unsigned int arg2 ;
70121   Dali::Actor result;
70122
70123   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70124   arg2 = (unsigned int)jarg2;
70125   {
70126     try {
70127       result = (arg1)->NewItem(arg2);
70128     } catch (std::out_of_range& e) {
70129       {
70130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70131       };
70132     } catch (std::exception& e) {
70133       {
70134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70135       };
70136     } catch (Dali::DaliException e) {
70137       {
70138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70139       };
70140     } catch (...) {
70141       {
70142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70143       };
70144     }
70145   }
70146
70147   jresult = new Dali::Actor((const Dali::Actor &)result);
70148   return jresult;
70149 }
70150
70151
70152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70153   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70154   unsigned int arg2 ;
70155   Dali::Actor arg3 ;
70156   Dali::Actor *argp3 ;
70157
70158   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70159   arg2 = (unsigned int)jarg2;
70160   argp3 = (Dali::Actor *)jarg3;
70161   if (!argp3) {
70162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70163     return ;
70164   }
70165   arg3 = *argp3;
70166   {
70167     try {
70168       (arg1)->ItemReleased(arg2,arg3);
70169     } catch (std::out_of_range& e) {
70170       {
70171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70172       };
70173     } catch (std::exception& e) {
70174       {
70175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70176       };
70177     } catch (Dali::DaliException e) {
70178       {
70179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70180       };
70181     } catch (...) {
70182       {
70183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70184       };
70185     }
70186   }
70187
70188 }
70189
70190
70191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70192   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70193   unsigned int arg2 ;
70194   Dali::Actor arg3 ;
70195   Dali::Actor *argp3 ;
70196
70197   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70198   arg2 = (unsigned int)jarg2;
70199   argp3 = (Dali::Actor *)jarg3;
70200   if (!argp3) {
70201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70202     return ;
70203   }
70204   arg3 = *argp3;
70205   {
70206     try {
70207       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70208     } catch (std::out_of_range& e) {
70209       {
70210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70211       };
70212     } catch (std::exception& e) {
70213       {
70214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70215       };
70216     } catch (Dali::DaliException e) {
70217       {
70218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70219       };
70220     } catch (...) {
70221       {
70222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70223       };
70224     }
70225   }
70226
70227 }
70228
70229
70230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70231   void * jresult ;
70232   Dali::Toolkit::ItemFactory *result = 0 ;
70233
70234   {
70235     try {
70236       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70237     } catch (std::out_of_range& e) {
70238       {
70239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70240       };
70241     } catch (std::exception& e) {
70242       {
70243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70244       };
70245     } catch (Dali::DaliException e) {
70246       {
70247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70248       };
70249     } catch (...) {
70250       {
70251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70252       };
70253     }
70254   }
70255
70256   jresult = (void *)result;
70257   return jresult;
70258 }
70259
70260
70261 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) {
70262   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70263   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70264   if (director) {
70265     director->swig_connect_director(callback0, callback1, callback2);
70266   }
70267 }
70268
70269
70270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70271   int jresult ;
70272   int result;
70273
70274   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70275   jresult = (int)result;
70276   return jresult;
70277 }
70278
70279
70280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70281   int jresult ;
70282   int result;
70283
70284   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70285   jresult = (int)result;
70286   return jresult;
70287 }
70288
70289
70290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70291   int jresult ;
70292   int result;
70293
70294   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70295   jresult = (int)result;
70296   return jresult;
70297 }
70298
70299
70300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70301   int jresult ;
70302   int result;
70303
70304   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70305   jresult = (int)result;
70306   return jresult;
70307 }
70308
70309
70310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70311   int jresult ;
70312   int result;
70313
70314   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70315   jresult = (int)result;
70316   return jresult;
70317 }
70318
70319
70320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70321   int jresult ;
70322   int result;
70323
70324   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70325   jresult = (int)result;
70326   return jresult;
70327 }
70328
70329
70330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70331   int jresult ;
70332   int result;
70333
70334   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70335   jresult = (int)result;
70336   return jresult;
70337 }
70338
70339
70340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70341   int jresult ;
70342   int result;
70343
70344   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70345   jresult = (int)result;
70346   return jresult;
70347 }
70348
70349
70350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70351   int jresult ;
70352   int result;
70353
70354   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70355   jresult = (int)result;
70356   return jresult;
70357 }
70358
70359
70360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70361   int jresult ;
70362   int result;
70363
70364   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70365   jresult = (int)result;
70366   return jresult;
70367 }
70368
70369
70370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70371   int jresult ;
70372   int result;
70373
70374   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70375   jresult = (int)result;
70376   return jresult;
70377 }
70378
70379
70380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70381   void * jresult ;
70382   Dali::Toolkit::ItemView::Property *result = 0 ;
70383
70384   {
70385     try {
70386       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70387     } catch (std::out_of_range& e) {
70388       {
70389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70390       };
70391     } catch (std::exception& e) {
70392       {
70393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70394       };
70395     } catch (Dali::DaliException e) {
70396       {
70397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70398       };
70399     } catch (...) {
70400       {
70401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70402       };
70403     }
70404   }
70405
70406   jresult = (void *)result;
70407   return jresult;
70408 }
70409
70410
70411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70412   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70413
70414   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70415   {
70416     try {
70417       delete arg1;
70418     } catch (std::out_of_range& e) {
70419       {
70420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70421       };
70422     } catch (std::exception& e) {
70423       {
70424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70425       };
70426     } catch (Dali::DaliException e) {
70427       {
70428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70429       };
70430     } catch (...) {
70431       {
70432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70433       };
70434     }
70435   }
70436
70437 }
70438
70439
70440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70441   void * jresult ;
70442   Dali::Toolkit::ItemView *result = 0 ;
70443
70444   {
70445     try {
70446       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70447     } catch (std::out_of_range& e) {
70448       {
70449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70450       };
70451     } catch (std::exception& e) {
70452       {
70453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70454       };
70455     } catch (Dali::DaliException e) {
70456       {
70457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70458       };
70459     } catch (...) {
70460       {
70461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70462       };
70463     }
70464   }
70465
70466   jresult = (void *)result;
70467   return jresult;
70468 }
70469
70470
70471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70472   void * jresult ;
70473   Dali::Toolkit::ItemView *arg1 = 0 ;
70474   Dali::Toolkit::ItemView *result = 0 ;
70475
70476   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70477   if (!arg1) {
70478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70479     return 0;
70480   }
70481   {
70482     try {
70483       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70484     } catch (std::out_of_range& e) {
70485       {
70486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70487       };
70488     } catch (std::exception& e) {
70489       {
70490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70491       };
70492     } catch (Dali::DaliException e) {
70493       {
70494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70495       };
70496     } catch (...) {
70497       {
70498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70499       };
70500     }
70501   }
70502
70503   jresult = (void *)result;
70504   return jresult;
70505 }
70506
70507
70508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70509   void * jresult ;
70510   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70511   Dali::Toolkit::ItemView *arg2 = 0 ;
70512   Dali::Toolkit::ItemView *result = 0 ;
70513
70514   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70515   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70516   if (!arg2) {
70517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70518     return 0;
70519   }
70520   {
70521     try {
70522       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70523     } catch (std::out_of_range& e) {
70524       {
70525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70526       };
70527     } catch (std::exception& e) {
70528       {
70529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70530       };
70531     } catch (Dali::DaliException e) {
70532       {
70533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70534       };
70535     } catch (...) {
70536       {
70537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70538       };
70539     }
70540   }
70541
70542   jresult = (void *)result;
70543   return jresult;
70544 }
70545
70546
70547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70548   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70549
70550   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70551   {
70552     try {
70553       delete arg1;
70554     } catch (std::out_of_range& e) {
70555       {
70556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70557       };
70558     } catch (std::exception& e) {
70559       {
70560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70561       };
70562     } catch (Dali::DaliException e) {
70563       {
70564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70565       };
70566     } catch (...) {
70567       {
70568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70569       };
70570     }
70571   }
70572
70573 }
70574
70575
70576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70577   void * jresult ;
70578   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70579   Dali::Toolkit::ItemView result;
70580
70581   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70582   if (!arg1) {
70583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70584     return 0;
70585   }
70586   {
70587     try {
70588       result = Dali::Toolkit::ItemView::New(*arg1);
70589     } catch (std::out_of_range& e) {
70590       {
70591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70592       };
70593     } catch (std::exception& e) {
70594       {
70595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70596       };
70597     } catch (Dali::DaliException e) {
70598       {
70599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70600       };
70601     } catch (...) {
70602       {
70603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70604       };
70605     }
70606   }
70607
70608   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70609   return jresult;
70610 }
70611
70612
70613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70614   void * jresult ;
70615   Dali::BaseHandle arg1 ;
70616   Dali::BaseHandle *argp1 ;
70617   Dali::Toolkit::ItemView result;
70618
70619   argp1 = (Dali::BaseHandle *)jarg1;
70620   if (!argp1) {
70621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70622     return 0;
70623   }
70624   arg1 = *argp1;
70625   {
70626     try {
70627       result = Dali::Toolkit::ItemView::DownCast(arg1);
70628     } catch (std::out_of_range& e) {
70629       {
70630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70631       };
70632     } catch (std::exception& e) {
70633       {
70634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70635       };
70636     } catch (Dali::DaliException e) {
70637       {
70638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70639       };
70640     } catch (...) {
70641       {
70642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70643       };
70644     }
70645   }
70646
70647   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70648   return jresult;
70649 }
70650
70651
70652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
70653   unsigned int jresult ;
70654   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70655   unsigned int result;
70656
70657   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70658   {
70659     try {
70660       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
70661     } catch (std::out_of_range& e) {
70662       {
70663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70664       };
70665     } catch (std::exception& e) {
70666       {
70667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70668       };
70669     } catch (Dali::DaliException e) {
70670       {
70671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70672       };
70673     } catch (...) {
70674       {
70675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70676       };
70677     }
70678   }
70679
70680   jresult = result;
70681   return jresult;
70682 }
70683
70684
70685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
70686   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70687   Dali::Toolkit::ItemLayout *arg2 = 0 ;
70688
70689   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70690   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
70691   if (!arg2) {
70692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
70693     return ;
70694   }
70695   {
70696     try {
70697       (arg1)->AddLayout(*arg2);
70698     } catch (std::out_of_range& e) {
70699       {
70700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70701       };
70702     } catch (std::exception& e) {
70703       {
70704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70705       };
70706     } catch (Dali::DaliException e) {
70707       {
70708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70709       };
70710     } catch (...) {
70711       {
70712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70713       };
70714     }
70715   }
70716
70717 }
70718
70719
70720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
70721   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70722   unsigned int arg2 ;
70723
70724   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70725   arg2 = (unsigned int)jarg2;
70726   {
70727     try {
70728       (arg1)->RemoveLayout(arg2);
70729     } catch (std::out_of_range& e) {
70730       {
70731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70732       };
70733     } catch (std::exception& e) {
70734       {
70735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70736       };
70737     } catch (Dali::DaliException e) {
70738       {
70739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70740       };
70741     } catch (...) {
70742       {
70743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70744       };
70745     }
70746   }
70747
70748 }
70749
70750
70751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70752   void * jresult ;
70753   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70754   unsigned int arg2 ;
70755   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70756
70757   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70758   arg2 = (unsigned int)jarg2;
70759   {
70760     try {
70761       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
70762     } catch (std::out_of_range& e) {
70763       {
70764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70765       };
70766     } catch (std::exception& e) {
70767       {
70768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70769       };
70770     } catch (Dali::DaliException e) {
70771       {
70772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70773       };
70774     } catch (...) {
70775       {
70776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70777       };
70778     }
70779   }
70780
70781   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70782   return jresult;
70783 }
70784
70785
70786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
70787   void * jresult ;
70788   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70789   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70790
70791   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70792   {
70793     try {
70794       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
70795     } catch (std::out_of_range& e) {
70796       {
70797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70798       };
70799     } catch (std::exception& e) {
70800       {
70801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70802       };
70803     } catch (Dali::DaliException e) {
70804       {
70805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70806       };
70807     } catch (...) {
70808       {
70809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70810       };
70811     }
70812   }
70813
70814   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70815   return jresult;
70816 }
70817
70818
70819 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
70820   float jresult ;
70821   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70822   Dali::Toolkit::ItemId arg2 ;
70823   float result;
70824
70825   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70826   arg2 = (Dali::Toolkit::ItemId)jarg2;
70827   {
70828     try {
70829       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
70830     } catch (std::out_of_range& e) {
70831       {
70832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70833       };
70834     } catch (std::exception& e) {
70835       {
70836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70837       };
70838     } catch (Dali::DaliException e) {
70839       {
70840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70841       };
70842     } catch (...) {
70843       {
70844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70845       };
70846     }
70847   }
70848
70849   jresult = result;
70850   return jresult;
70851 }
70852
70853
70854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
70855   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70856   unsigned int arg2 ;
70857   Dali::Vector3 arg3 ;
70858   float arg4 ;
70859   Dali::Vector3 *argp3 ;
70860
70861   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70862   arg2 = (unsigned int)jarg2;
70863   argp3 = (Dali::Vector3 *)jarg3;
70864   if (!argp3) {
70865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70866     return ;
70867   }
70868   arg3 = *argp3;
70869   arg4 = (float)jarg4;
70870   {
70871     try {
70872       (arg1)->ActivateLayout(arg2,arg3,arg4);
70873     } catch (std::out_of_range& e) {
70874       {
70875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70876       };
70877     } catch (std::exception& e) {
70878       {
70879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70880       };
70881     } catch (Dali::DaliException e) {
70882       {
70883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70884       };
70885     } catch (...) {
70886       {
70887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70888       };
70889     }
70890   }
70891
70892 }
70893
70894
70895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
70896   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70897
70898   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70899   {
70900     try {
70901       (arg1)->DeactivateCurrentLayout();
70902     } catch (std::out_of_range& e) {
70903       {
70904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70905       };
70906     } catch (std::exception& e) {
70907       {
70908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70909       };
70910     } catch (Dali::DaliException e) {
70911       {
70912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70913       };
70914     } catch (...) {
70915       {
70916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70917       };
70918     }
70919   }
70920
70921 }
70922
70923
70924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
70925   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70926   float arg2 ;
70927
70928   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70929   arg2 = (float)jarg2;
70930   {
70931     try {
70932       (arg1)->SetMinimumSwipeSpeed(arg2);
70933     } catch (std::out_of_range& e) {
70934       {
70935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70936       };
70937     } catch (std::exception& e) {
70938       {
70939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70940       };
70941     } catch (Dali::DaliException e) {
70942       {
70943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70944       };
70945     } catch (...) {
70946       {
70947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70948       };
70949     }
70950   }
70951
70952 }
70953
70954
70955 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
70956   float jresult ;
70957   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70958   float result;
70959
70960   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70961   {
70962     try {
70963       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
70964     } catch (std::out_of_range& e) {
70965       {
70966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70967       };
70968     } catch (std::exception& e) {
70969       {
70970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70971       };
70972     } catch (Dali::DaliException e) {
70973       {
70974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70975       };
70976     } catch (...) {
70977       {
70978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70979       };
70980     }
70981   }
70982
70983   jresult = result;
70984   return jresult;
70985 }
70986
70987
70988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
70989   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70990   float arg2 ;
70991
70992   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70993   arg2 = (float)jarg2;
70994   {
70995     try {
70996       (arg1)->SetMinimumSwipeDistance(arg2);
70997     } catch (std::out_of_range& e) {
70998       {
70999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71000       };
71001     } catch (std::exception& e) {
71002       {
71003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71004       };
71005     } catch (Dali::DaliException e) {
71006       {
71007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71008       };
71009     } catch (...) {
71010       {
71011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71012       };
71013     }
71014   }
71015
71016 }
71017
71018
71019 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71020   float jresult ;
71021   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71022   float result;
71023
71024   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71025   {
71026     try {
71027       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71028     } catch (std::out_of_range& e) {
71029       {
71030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71031       };
71032     } catch (std::exception& e) {
71033       {
71034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71035       };
71036     } catch (Dali::DaliException e) {
71037       {
71038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71039       };
71040     } catch (...) {
71041       {
71042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71043       };
71044     }
71045   }
71046
71047   jresult = result;
71048   return jresult;
71049 }
71050
71051
71052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71053   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71054   float arg2 ;
71055
71056   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71057   arg2 = (float)jarg2;
71058   {
71059     try {
71060       (arg1)->SetWheelScrollDistanceStep(arg2);
71061     } catch (std::out_of_range& e) {
71062       {
71063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71064       };
71065     } catch (std::exception& e) {
71066       {
71067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71068       };
71069     } catch (Dali::DaliException e) {
71070       {
71071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71072       };
71073     } catch (...) {
71074       {
71075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71076       };
71077     }
71078   }
71079
71080 }
71081
71082
71083 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71084   float jresult ;
71085   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71086   float result;
71087
71088   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71089   {
71090     try {
71091       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71092     } catch (std::out_of_range& e) {
71093       {
71094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71095       };
71096     } catch (std::exception& e) {
71097       {
71098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71099       };
71100     } catch (Dali::DaliException e) {
71101       {
71102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71103       };
71104     } catch (...) {
71105       {
71106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71107       };
71108     }
71109   }
71110
71111   jresult = result;
71112   return jresult;
71113 }
71114
71115
71116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71117   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71118   bool arg2 ;
71119
71120   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71121   arg2 = jarg2 ? true : false;
71122   {
71123     try {
71124       (arg1)->SetAnchoring(arg2);
71125     } catch (std::out_of_range& e) {
71126       {
71127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71128       };
71129     } catch (std::exception& e) {
71130       {
71131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71132       };
71133     } catch (Dali::DaliException e) {
71134       {
71135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71136       };
71137     } catch (...) {
71138       {
71139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71140       };
71141     }
71142   }
71143
71144 }
71145
71146 //// ========================= end of part 3 =============================
71147
71148 //// ========================== start part 4 ===============================
71149
71150
71151 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71152   unsigned int jresult ;
71153   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71154   bool result;
71155
71156   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71157   {
71158     try {
71159       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71160     } catch (std::out_of_range& e) {
71161       {
71162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71163       };
71164     } catch (std::exception& e) {
71165       {
71166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71167       };
71168     } catch (Dali::DaliException e) {
71169       {
71170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71171       };
71172     } catch (...) {
71173       {
71174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71175       };
71176     }
71177   }
71178
71179   jresult = result;
71180   return jresult;
71181 }
71182
71183
71184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71185   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71186   float arg2 ;
71187
71188   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71189   arg2 = (float)jarg2;
71190   {
71191     try {
71192       (arg1)->SetAnchoringDuration(arg2);
71193     } catch (std::out_of_range& e) {
71194       {
71195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71196       };
71197     } catch (std::exception& e) {
71198       {
71199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71200       };
71201     } catch (Dali::DaliException e) {
71202       {
71203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71204       };
71205     } catch (...) {
71206       {
71207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71208       };
71209     }
71210   }
71211
71212 }
71213
71214
71215 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71216   float jresult ;
71217   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71218   float result;
71219
71220   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71221   {
71222     try {
71223       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71224     } catch (std::out_of_range& e) {
71225       {
71226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71227       };
71228     } catch (std::exception& e) {
71229       {
71230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71231       };
71232     } catch (Dali::DaliException e) {
71233       {
71234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71235       };
71236     } catch (...) {
71237       {
71238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71239       };
71240     }
71241   }
71242
71243   jresult = result;
71244   return jresult;
71245 }
71246
71247
71248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71249   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71250   Dali::Toolkit::ItemId arg2 ;
71251   float arg3 ;
71252
71253   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71254   arg2 = (Dali::Toolkit::ItemId)jarg2;
71255   arg3 = (float)jarg3;
71256   {
71257     try {
71258       (arg1)->ScrollToItem(arg2,arg3);
71259     } catch (std::out_of_range& e) {
71260       {
71261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71262       };
71263     } catch (std::exception& e) {
71264       {
71265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71266       };
71267     } catch (Dali::DaliException e) {
71268       {
71269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71270       };
71271     } catch (...) {
71272       {
71273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71274       };
71275     }
71276   }
71277
71278 }
71279
71280
71281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71282   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71283   float arg2 ;
71284
71285   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71286   arg2 = (float)jarg2;
71287   {
71288     try {
71289       (arg1)->SetRefreshInterval(arg2);
71290     } catch (std::out_of_range& e) {
71291       {
71292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71293       };
71294     } catch (std::exception& e) {
71295       {
71296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71297       };
71298     } catch (Dali::DaliException e) {
71299       {
71300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71301       };
71302     } catch (...) {
71303       {
71304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71305       };
71306     }
71307   }
71308
71309 }
71310
71311
71312 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71313   float jresult ;
71314   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71315   float result;
71316
71317   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71318   {
71319     try {
71320       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71321     } catch (std::out_of_range& e) {
71322       {
71323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71324       };
71325     } catch (std::exception& e) {
71326       {
71327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71328       };
71329     } catch (Dali::DaliException e) {
71330       {
71331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71332       };
71333     } catch (...) {
71334       {
71335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71336       };
71337     }
71338   }
71339
71340   jresult = result;
71341   return jresult;
71342 }
71343
71344
71345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71346   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71347
71348   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71349   {
71350     try {
71351       (arg1)->Refresh();
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_GetItem(void * jarg1, unsigned int jarg2) {
71375   void * jresult ;
71376   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71377   Dali::Toolkit::ItemId arg2 ;
71378   Dali::Actor result;
71379
71380   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71381   arg2 = (Dali::Toolkit::ItemId)jarg2;
71382   {
71383     try {
71384       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71385     } catch (std::out_of_range& e) {
71386       {
71387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71388       };
71389     } catch (std::exception& e) {
71390       {
71391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71392       };
71393     } catch (Dali::DaliException e) {
71394       {
71395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71396       };
71397     } catch (...) {
71398       {
71399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71400       };
71401     }
71402   }
71403
71404   jresult = new Dali::Actor((const Dali::Actor &)result);
71405   return jresult;
71406 }
71407
71408
71409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71410   unsigned int jresult ;
71411   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71412   Dali::Actor arg2 ;
71413   Dali::Actor *argp2 ;
71414   Dali::Toolkit::ItemId result;
71415
71416   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71417   argp2 = (Dali::Actor *)jarg2;
71418   if (!argp2) {
71419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71420     return 0;
71421   }
71422   arg2 = *argp2;
71423   {
71424     try {
71425       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71426     } catch (std::out_of_range& e) {
71427       {
71428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71429       };
71430     } catch (std::exception& e) {
71431       {
71432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71433       };
71434     } catch (Dali::DaliException e) {
71435       {
71436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71437       };
71438     } catch (...) {
71439       {
71440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71441       };
71442     }
71443   }
71444
71445   jresult = result;
71446   return jresult;
71447 }
71448
71449
71450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71451   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71452   Dali::Toolkit::Item arg2 ;
71453   float arg3 ;
71454   Dali::Toolkit::Item *argp2 ;
71455
71456   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71457   argp2 = (Dali::Toolkit::Item *)jarg2;
71458   if (!argp2) {
71459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71460     return ;
71461   }
71462   arg2 = *argp2;
71463   arg3 = (float)jarg3;
71464   {
71465     try {
71466       (arg1)->InsertItem(arg2,arg3);
71467     } catch (std::out_of_range& e) {
71468       {
71469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71470       };
71471     } catch (std::exception& e) {
71472       {
71473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71474       };
71475     } catch (Dali::DaliException e) {
71476       {
71477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71478       };
71479     } catch (...) {
71480       {
71481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71482       };
71483     }
71484   }
71485
71486 }
71487
71488
71489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71490   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71491   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71492   float arg3 ;
71493
71494   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71495   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71496   if (!arg2) {
71497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71498     return ;
71499   }
71500   arg3 = (float)jarg3;
71501   {
71502     try {
71503       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71504     } catch (std::out_of_range& e) {
71505       {
71506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71507       };
71508     } catch (std::exception& e) {
71509       {
71510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71511       };
71512     } catch (Dali::DaliException e) {
71513       {
71514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71515       };
71516     } catch (...) {
71517       {
71518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71519       };
71520     }
71521   }
71522
71523 }
71524
71525
71526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71527   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71528   Dali::Toolkit::ItemId arg2 ;
71529   float arg3 ;
71530
71531   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71532   arg2 = (Dali::Toolkit::ItemId)jarg2;
71533   arg3 = (float)jarg3;
71534   {
71535     try {
71536       (arg1)->RemoveItem(arg2,arg3);
71537     } catch (std::out_of_range& e) {
71538       {
71539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71540       };
71541     } catch (std::exception& e) {
71542       {
71543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71544       };
71545     } catch (Dali::DaliException e) {
71546       {
71547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71548       };
71549     } catch (...) {
71550       {
71551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71552       };
71553     }
71554   }
71555
71556 }
71557
71558
71559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71560   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71561   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71562   float arg3 ;
71563
71564   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71565   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71566   if (!arg2) {
71567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71568     return ;
71569   }
71570   arg3 = (float)jarg3;
71571   {
71572     try {
71573       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71574     } catch (std::out_of_range& e) {
71575       {
71576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71577       };
71578     } catch (std::exception& e) {
71579       {
71580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71581       };
71582     } catch (Dali::DaliException e) {
71583       {
71584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71585       };
71586     } catch (...) {
71587       {
71588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71589       };
71590     }
71591   }
71592
71593 }
71594
71595
71596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71597   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71598   Dali::Toolkit::Item arg2 ;
71599   float arg3 ;
71600   Dali::Toolkit::Item *argp2 ;
71601
71602   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71603   argp2 = (Dali::Toolkit::Item *)jarg2;
71604   if (!argp2) {
71605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71606     return ;
71607   }
71608   arg2 = *argp2;
71609   arg3 = (float)jarg3;
71610   {
71611     try {
71612       (arg1)->ReplaceItem(arg2,arg3);
71613     } catch (std::out_of_range& e) {
71614       {
71615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71616       };
71617     } catch (std::exception& e) {
71618       {
71619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71620       };
71621     } catch (Dali::DaliException e) {
71622       {
71623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71624       };
71625     } catch (...) {
71626       {
71627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71628       };
71629     }
71630   }
71631
71632 }
71633
71634
71635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71636   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71637   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71638   float arg3 ;
71639
71640   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71641   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71642   if (!arg2) {
71643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71644     return ;
71645   }
71646   arg3 = (float)jarg3;
71647   {
71648     try {
71649       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71650     } catch (std::out_of_range& e) {
71651       {
71652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71653       };
71654     } catch (std::exception& e) {
71655       {
71656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71657       };
71658     } catch (Dali::DaliException e) {
71659       {
71660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71661       };
71662     } catch (...) {
71663       {
71664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71665       };
71666     }
71667   }
71668
71669 }
71670
71671
71672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71673   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71674   Dali::Vector3 *arg2 = 0 ;
71675
71676   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71677   arg2 = (Dali::Vector3 *)jarg2;
71678   if (!arg2) {
71679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71680     return ;
71681   }
71682   {
71683     try {
71684       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71685     } catch (std::out_of_range& e) {
71686       {
71687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71688       };
71689     } catch (std::exception& e) {
71690       {
71691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71692       };
71693     } catch (Dali::DaliException e) {
71694       {
71695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71696       };
71697     } catch (...) {
71698       {
71699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71700       };
71701     }
71702   }
71703
71704 }
71705
71706
71707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
71708   void * jresult ;
71709   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71710   Dali::Vector3 result;
71711
71712   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71713   {
71714     try {
71715       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71716     } catch (std::out_of_range& e) {
71717       {
71718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71719       };
71720     } catch (std::exception& e) {
71721       {
71722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71723       };
71724     } catch (Dali::DaliException e) {
71725       {
71726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71727       };
71728     } catch (...) {
71729       {
71730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71731       };
71732     }
71733   }
71734
71735   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71736   return jresult;
71737 }
71738
71739
71740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71741   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71742   Dali::Vector3 *arg2 = 0 ;
71743
71744   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71745   arg2 = (Dali::Vector3 *)jarg2;
71746   if (!arg2) {
71747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71748     return ;
71749   }
71750   {
71751     try {
71752       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71753     } catch (std::out_of_range& e) {
71754       {
71755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71756       };
71757     } catch (std::exception& e) {
71758       {
71759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71760       };
71761     } catch (Dali::DaliException e) {
71762       {
71763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71764       };
71765     } catch (...) {
71766       {
71767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71768       };
71769     }
71770   }
71771
71772 }
71773
71774
71775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
71776   void * jresult ;
71777   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71778   Dali::Vector3 result;
71779
71780   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71781   {
71782     try {
71783       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
71784     } catch (std::out_of_range& e) {
71785       {
71786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71787       };
71788     } catch (std::exception& e) {
71789       {
71790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71791       };
71792     } catch (Dali::DaliException e) {
71793       {
71794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71795       };
71796     } catch (...) {
71797       {
71798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71799       };
71800     }
71801   }
71802
71803   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71804   return jresult;
71805 }
71806
71807
71808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
71809   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71810   Dali::Toolkit::ItemRange *arg2 = 0 ;
71811
71812   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71813   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
71814   if (!arg2) {
71815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
71816     return ;
71817   }
71818   {
71819     try {
71820       (arg1)->GetItemsRange(*arg2);
71821     } catch (std::out_of_range& e) {
71822       {
71823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71824       };
71825     } catch (std::exception& e) {
71826       {
71827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71828       };
71829     } catch (Dali::DaliException e) {
71830       {
71831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71832       };
71833     } catch (...) {
71834       {
71835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71836       };
71837     }
71838   }
71839
71840 }
71841
71842
71843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
71844   void * jresult ;
71845   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71846   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
71847
71848   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71849   {
71850     try {
71851       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
71852     } catch (std::out_of_range& e) {
71853       {
71854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71855       };
71856     } catch (std::exception& e) {
71857       {
71858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71859       };
71860     } catch (Dali::DaliException e) {
71861       {
71862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71863       };
71864     } catch (...) {
71865       {
71866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71867       };
71868     }
71869   }
71870
71871   jresult = (void *)result;
71872   return jresult;
71873 }
71874
71875
71876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
71877   Dali::Vector3 *arg1 = 0 ;
71878   PropertyInputContainer *arg2 = 0 ;
71879
71880   arg1 = (Dali::Vector3 *)jarg1;
71881   if (!arg1) {
71882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71883     return ;
71884   }
71885   arg2 = (PropertyInputContainer *)jarg2;
71886   if (!arg2) {
71887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71888     return ;
71889   }
71890   {
71891     try {
71892       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71893     } catch (std::out_of_range& e) {
71894       {
71895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71896       };
71897     } catch (std::exception& e) {
71898       {
71899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71900       };
71901     } catch (Dali::DaliException e) {
71902       {
71903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71904       };
71905     } catch (...) {
71906       {
71907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71908       };
71909     }
71910   }
71911
71912 }
71913
71914
71915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
71916   Dali::Vector3 *arg1 = 0 ;
71917   PropertyInputContainer *arg2 = 0 ;
71918
71919   arg1 = (Dali::Vector3 *)jarg1;
71920   if (!arg1) {
71921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71922     return ;
71923   }
71924   arg2 = (PropertyInputContainer *)jarg2;
71925   if (!arg2) {
71926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71927     return ;
71928   }
71929   {
71930     try {
71931       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71932     } catch (std::out_of_range& e) {
71933       {
71934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71935       };
71936     } catch (std::exception& e) {
71937       {
71938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71939       };
71940     } catch (Dali::DaliException e) {
71941       {
71942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71943       };
71944     } catch (...) {
71945       {
71946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71947       };
71948     }
71949   }
71950
71951 }
71952
71953
71954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
71955   void * jresult ;
71956   Dali::Toolkit::ScrollViewEffect *result = 0 ;
71957
71958   {
71959     try {
71960       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
71961     } catch (std::out_of_range& e) {
71962       {
71963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71964       };
71965     } catch (std::exception& e) {
71966       {
71967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71968       };
71969     } catch (Dali::DaliException e) {
71970       {
71971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71972       };
71973     } catch (...) {
71974       {
71975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71976       };
71977     }
71978   }
71979
71980   jresult = (void *)result;
71981   return jresult;
71982 }
71983
71984
71985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
71986   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
71987
71988   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
71989   {
71990     try {
71991       delete arg1;
71992     } catch (std::out_of_range& e) {
71993       {
71994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71995       };
71996     } catch (std::exception& e) {
71997       {
71998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71999       };
72000     } catch (Dali::DaliException e) {
72001       {
72002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72003       };
72004     } catch (...) {
72005       {
72006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72007       };
72008     }
72009   }
72010
72011 }
72012
72013
72014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72015   void * jresult ;
72016   Dali::Path arg1 ;
72017   Dali::Vector3 *arg2 = 0 ;
72018   Dali::Property::Index arg3 ;
72019   Dali::Vector3 *arg4 = 0 ;
72020   unsigned int arg5 ;
72021   Dali::Path *argp1 ;
72022   Dali::Toolkit::ScrollViewPagePathEffect result;
72023
72024   argp1 = (Dali::Path *)jarg1;
72025   if (!argp1) {
72026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72027     return 0;
72028   }
72029   arg1 = *argp1;
72030   arg2 = (Dali::Vector3 *)jarg2;
72031   if (!arg2) {
72032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72033     return 0;
72034   }
72035   arg3 = (Dali::Property::Index)jarg3;
72036   arg4 = (Dali::Vector3 *)jarg4;
72037   if (!arg4) {
72038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72039     return 0;
72040   }
72041   arg5 = (unsigned int)jarg5;
72042   {
72043     try {
72044       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72045     } catch (std::out_of_range& e) {
72046       {
72047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72048       };
72049     } catch (std::exception& e) {
72050       {
72051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72052       };
72053     } catch (Dali::DaliException e) {
72054       {
72055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72056       };
72057     } catch (...) {
72058       {
72059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72060       };
72061     }
72062   }
72063
72064   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72065   return jresult;
72066 }
72067
72068
72069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72070   void * jresult ;
72071   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72072
72073   {
72074     try {
72075       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72076     } catch (std::out_of_range& e) {
72077       {
72078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72079       };
72080     } catch (std::exception& e) {
72081       {
72082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72083       };
72084     } catch (Dali::DaliException e) {
72085       {
72086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72087       };
72088     } catch (...) {
72089       {
72090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72091       };
72092     }
72093   }
72094
72095   jresult = (void *)result;
72096   return jresult;
72097 }
72098
72099
72100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72101   void * jresult ;
72102   Dali::BaseHandle arg1 ;
72103   Dali::BaseHandle *argp1 ;
72104   Dali::Toolkit::ScrollViewPagePathEffect result;
72105
72106   argp1 = (Dali::BaseHandle *)jarg1;
72107   if (!argp1) {
72108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72109     return 0;
72110   }
72111   arg1 = *argp1;
72112   {
72113     try {
72114       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72115     } catch (std::out_of_range& e) {
72116       {
72117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72118       };
72119     } catch (std::exception& e) {
72120       {
72121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72122       };
72123     } catch (Dali::DaliException e) {
72124       {
72125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72126       };
72127     } catch (...) {
72128       {
72129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72130       };
72131     }
72132   }
72133
72134   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72135   return jresult;
72136 }
72137
72138
72139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72140   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72141   Dali::Actor arg2 ;
72142   unsigned int arg3 ;
72143   Dali::Actor *argp2 ;
72144
72145   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72146   argp2 = (Dali::Actor *)jarg2;
72147   if (!argp2) {
72148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72149     return ;
72150   }
72151   arg2 = *argp2;
72152   arg3 = (unsigned int)jarg3;
72153   {
72154     try {
72155       (arg1)->ApplyToPage(arg2,arg3);
72156     } catch (std::out_of_range& e) {
72157       {
72158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72159       };
72160     } catch (std::exception& e) {
72161       {
72162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72163       };
72164     } catch (Dali::DaliException e) {
72165       {
72166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72167       };
72168     } catch (...) {
72169       {
72170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72171       };
72172     }
72173   }
72174
72175 }
72176
72177
72178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72179   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72180
72181   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72182   {
72183     try {
72184       delete arg1;
72185     } catch (std::out_of_range& e) {
72186       {
72187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72188       };
72189     } catch (std::exception& e) {
72190       {
72191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72192       };
72193     } catch (Dali::DaliException e) {
72194       {
72195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72196       };
72197     } catch (...) {
72198       {
72199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72200       };
72201     }
72202   }
72203
72204 }
72205
72206
72207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
72208   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72209   Dali::Toolkit::ClampState arg2 ;
72210
72211   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72212   arg2 = (Dali::Toolkit::ClampState)jarg2;
72213   if (arg1) (arg1)->x = arg2;
72214 }
72215
72216
72217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
72218   int jresult ;
72219   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72220   Dali::Toolkit::ClampState result;
72221
72222   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72223   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72224   jresult = (int)result;
72225   return jresult;
72226 }
72227
72228
72229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72230   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72231   Dali::Toolkit::ClampState arg2 ;
72232
72233   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72234   arg2 = (Dali::Toolkit::ClampState)jarg2;
72235   if (arg1) (arg1)->y = arg2;
72236 }
72237
72238
72239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72240   int jresult ;
72241   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72242   Dali::Toolkit::ClampState result;
72243
72244   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72245   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72246   jresult = (int)result;
72247   return jresult;
72248 }
72249
72250
72251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72252   void * jresult ;
72253   Dali::Toolkit::ClampState2D *result = 0 ;
72254
72255   {
72256     try {
72257       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72258     } catch (std::out_of_range& e) {
72259       {
72260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72261       };
72262     } catch (std::exception& e) {
72263       {
72264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72265       };
72266     } catch (Dali::DaliException e) {
72267       {
72268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72269       };
72270     } catch (...) {
72271       {
72272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72273       };
72274     }
72275   }
72276
72277   jresult = (void *)result;
72278   return jresult;
72279 }
72280
72281
72282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72283   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72284
72285   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72286   {
72287     try {
72288       delete arg1;
72289     } catch (std::out_of_range& e) {
72290       {
72291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72292       };
72293     } catch (std::exception& e) {
72294       {
72295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72296       };
72297     } catch (Dali::DaliException e) {
72298       {
72299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72300       };
72301     } catch (...) {
72302       {
72303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72304       };
72305     }
72306   }
72307
72308 }
72309
72310
72311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72312   void * jresult ;
72313   float arg1 ;
72314   float arg2 ;
72315   bool arg3 ;
72316   Dali::Toolkit::RulerDomain *result = 0 ;
72317
72318   arg1 = (float)jarg1;
72319   arg2 = (float)jarg2;
72320   arg3 = jarg3 ? true : false;
72321   {
72322     try {
72323       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72324     } catch (std::out_of_range& e) {
72325       {
72326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72327       };
72328     } catch (std::exception& e) {
72329       {
72330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72331       };
72332     } catch (Dali::DaliException e) {
72333       {
72334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72335       };
72336     } catch (...) {
72337       {
72338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72339       };
72340     }
72341   }
72342
72343   jresult = (void *)result;
72344   return jresult;
72345 }
72346
72347
72348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72349   void * jresult ;
72350   float arg1 ;
72351   float arg2 ;
72352   Dali::Toolkit::RulerDomain *result = 0 ;
72353
72354   arg1 = (float)jarg1;
72355   arg2 = (float)jarg2;
72356   {
72357     try {
72358       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72359     } catch (std::out_of_range& e) {
72360       {
72361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72362       };
72363     } catch (std::exception& e) {
72364       {
72365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72366       };
72367     } catch (Dali::DaliException e) {
72368       {
72369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72370       };
72371     } catch (...) {
72372       {
72373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72374       };
72375     }
72376   }
72377
72378   jresult = (void *)result;
72379   return jresult;
72380 }
72381
72382
72383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
72384   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72385   float arg2 ;
72386
72387   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72388   arg2 = (float)jarg2;
72389   if (arg1) (arg1)->min = arg2;
72390 }
72391
72392
72393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
72394   float jresult ;
72395   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72396   float result;
72397
72398   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72399   result = (float) ((arg1)->min);
72400   jresult = result;
72401   return jresult;
72402 }
72403
72404
72405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72406   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72407   float arg2 ;
72408
72409   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72410   arg2 = (float)jarg2;
72411   if (arg1) (arg1)->max = arg2;
72412 }
72413
72414
72415 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72416   float jresult ;
72417   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72418   float result;
72419
72420   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72421   result = (float) ((arg1)->max);
72422   jresult = result;
72423   return jresult;
72424 }
72425
72426
72427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72428   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72429   bool arg2 ;
72430
72431   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72432   arg2 = jarg2 ? true : false;
72433   if (arg1) (arg1)->enabled = arg2;
72434 }
72435
72436
72437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72438   unsigned int jresult ;
72439   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72440   bool result;
72441
72442   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72443   result = (bool) ((arg1)->enabled);
72444   jresult = result;
72445   return jresult;
72446 }
72447
72448
72449 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72450   float jresult ;
72451   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72452   float arg2 ;
72453   float arg3 ;
72454   float arg4 ;
72455   float result;
72456
72457   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72458   arg2 = (float)jarg2;
72459   arg3 = (float)jarg3;
72460   arg4 = (float)jarg4;
72461   {
72462     try {
72463       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72464     } catch (std::out_of_range& e) {
72465       {
72466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72467       };
72468     } catch (std::exception& e) {
72469       {
72470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72471       };
72472     } catch (Dali::DaliException e) {
72473       {
72474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72475       };
72476     } catch (...) {
72477       {
72478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72479       };
72480     }
72481   }
72482
72483   jresult = result;
72484   return jresult;
72485 }
72486
72487
72488 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72489   float jresult ;
72490   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72491   float arg2 ;
72492   float arg3 ;
72493   float result;
72494
72495   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72496   arg2 = (float)jarg2;
72497   arg3 = (float)jarg3;
72498   {
72499     try {
72500       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72501     } catch (std::out_of_range& e) {
72502       {
72503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72504       };
72505     } catch (std::exception& e) {
72506       {
72507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72508       };
72509     } catch (Dali::DaliException e) {
72510       {
72511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72512       };
72513     } catch (...) {
72514       {
72515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72516       };
72517     }
72518   }
72519
72520   jresult = result;
72521   return jresult;
72522 }
72523
72524
72525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72526   float jresult ;
72527   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72528   float arg2 ;
72529   float result;
72530
72531   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72532   arg2 = (float)jarg2;
72533   {
72534     try {
72535       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72536     } catch (std::out_of_range& e) {
72537       {
72538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72539       };
72540     } catch (std::exception& e) {
72541       {
72542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72543       };
72544     } catch (Dali::DaliException e) {
72545       {
72546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72547       };
72548     } catch (...) {
72549       {
72550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72551       };
72552     }
72553   }
72554
72555   jresult = result;
72556   return jresult;
72557 }
72558
72559
72560 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72561   float jresult ;
72562   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72563   float arg2 ;
72564   float arg3 ;
72565   float arg4 ;
72566   Dali::Toolkit::ClampState *arg5 = 0 ;
72567   float result;
72568
72569   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72570   arg2 = (float)jarg2;
72571   arg3 = (float)jarg3;
72572   arg4 = (float)jarg4;
72573   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72574   if (!arg5) {
72575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72576     return 0;
72577   }
72578   {
72579     try {
72580       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72581     } catch (std::out_of_range& e) {
72582       {
72583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72584       };
72585     } catch (std::exception& e) {
72586       {
72587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72588       };
72589     } catch (Dali::DaliException e) {
72590       {
72591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72592       };
72593     } catch (...) {
72594       {
72595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72596       };
72597     }
72598   }
72599
72600   jresult = result;
72601   return jresult;
72602 }
72603
72604
72605 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
72606   float jresult ;
72607   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72608   float result;
72609
72610   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72611   {
72612     try {
72613       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72614     } catch (std::out_of_range& e) {
72615       {
72616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72617       };
72618     } catch (std::exception& e) {
72619       {
72620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72621       };
72622     } catch (Dali::DaliException e) {
72623       {
72624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72625       };
72626     } catch (...) {
72627       {
72628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72629       };
72630     }
72631   }
72632
72633   jresult = result;
72634   return jresult;
72635 }
72636
72637
72638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72639   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72640
72641   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72642   {
72643     try {
72644       delete arg1;
72645     } catch (std::out_of_range& e) {
72646       {
72647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72648       };
72649     } catch (std::exception& e) {
72650       {
72651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72652       };
72653     } catch (Dali::DaliException e) {
72654       {
72655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72656       };
72657     } catch (...) {
72658       {
72659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72660       };
72661     }
72662   }
72663
72664 }
72665
72666
72667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72668   float jresult ;
72669   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72670   float arg2 ;
72671   float arg3 ;
72672   float result;
72673
72674   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72675   arg2 = (float)jarg2;
72676   arg3 = (float)jarg3;
72677   {
72678     try {
72679       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72680     } catch (std::out_of_range& e) {
72681       {
72682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72683       };
72684     } catch (std::exception& e) {
72685       {
72686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72687       };
72688     } catch (Dali::DaliException e) {
72689       {
72690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72691       };
72692     } catch (...) {
72693       {
72694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72695       };
72696     }
72697   }
72698
72699   jresult = result;
72700   return jresult;
72701 }
72702
72703
72704 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72705   float jresult ;
72706   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72707   float arg2 ;
72708   float result;
72709
72710   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72711   arg2 = (float)jarg2;
72712   {
72713     try {
72714       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72715     } catch (std::out_of_range& e) {
72716       {
72717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72718       };
72719     } catch (std::exception& e) {
72720       {
72721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72722       };
72723     } catch (Dali::DaliException e) {
72724       {
72725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72726       };
72727     } catch (...) {
72728       {
72729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72730       };
72731     }
72732   }
72733
72734   jresult = result;
72735   return jresult;
72736 }
72737
72738
72739 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72740   float jresult ;
72741   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72742   unsigned int arg2 ;
72743   unsigned int *arg3 = 0 ;
72744   bool arg4 ;
72745   float result;
72746
72747   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72748   arg2 = (unsigned int)jarg2;
72749   arg3 = (unsigned int *)jarg3;
72750   arg4 = jarg4 ? true : false;
72751   {
72752     try {
72753       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72754     } catch (std::out_of_range& e) {
72755       {
72756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72757       };
72758     } catch (std::exception& e) {
72759       {
72760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72761       };
72762     } catch (Dali::DaliException e) {
72763       {
72764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72765       };
72766     } catch (...) {
72767       {
72768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72769       };
72770     }
72771   }
72772
72773   jresult = result;
72774   return jresult;
72775 }
72776
72777
72778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72779   unsigned int jresult ;
72780   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72781   float arg2 ;
72782   bool arg3 ;
72783   unsigned int result;
72784
72785   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72786   arg2 = (float)jarg2;
72787   arg3 = jarg3 ? true : false;
72788   {
72789     try {
72790       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72791     } catch (std::out_of_range& e) {
72792       {
72793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72794       };
72795     } catch (std::exception& e) {
72796       {
72797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72798       };
72799     } catch (Dali::DaliException e) {
72800       {
72801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72802       };
72803     } catch (...) {
72804       {
72805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72806       };
72807     }
72808   }
72809
72810   jresult = result;
72811   return jresult;
72812 }
72813
72814
72815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
72816   unsigned int jresult ;
72817   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72818   unsigned int result;
72819
72820   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72821   {
72822     try {
72823       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
72824     } catch (std::out_of_range& e) {
72825       {
72826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72827       };
72828     } catch (std::exception& e) {
72829       {
72830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72831       };
72832     } catch (Dali::DaliException e) {
72833       {
72834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72835       };
72836     } catch (...) {
72837       {
72838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72839       };
72840     }
72841   }
72842
72843   jresult = result;
72844   return jresult;
72845 }
72846
72847
72848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
72849   int jresult ;
72850   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72851   Dali::Toolkit::Ruler::RulerType result;
72852
72853   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72854   {
72855     try {
72856       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
72857     } catch (std::out_of_range& e) {
72858       {
72859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72860       };
72861     } catch (std::exception& e) {
72862       {
72863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72864       };
72865     } catch (Dali::DaliException e) {
72866       {
72867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72868       };
72869     } catch (...) {
72870       {
72871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72872       };
72873     }
72874   }
72875
72876   jresult = (int)result;
72877   return jresult;
72878 }
72879
72880
72881 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
72882   unsigned int jresult ;
72883   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72884   bool result;
72885
72886   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72887   {
72888     try {
72889       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
72890     } catch (std::out_of_range& e) {
72891       {
72892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72893       };
72894     } catch (std::exception& e) {
72895       {
72896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72897       };
72898     } catch (Dali::DaliException e) {
72899       {
72900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72901       };
72902     } catch (...) {
72903       {
72904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72905       };
72906     }
72907   }
72908
72909   jresult = result;
72910   return jresult;
72911 }
72912
72913
72914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
72915   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72916
72917   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72918   {
72919     try {
72920       (arg1)->Enable();
72921     } catch (std::out_of_range& e) {
72922       {
72923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72924       };
72925     } catch (std::exception& e) {
72926       {
72927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72928       };
72929     } catch (Dali::DaliException e) {
72930       {
72931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72932       };
72933     } catch (...) {
72934       {
72935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72936       };
72937     }
72938   }
72939
72940 }
72941
72942
72943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
72944   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72945
72946   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72947   {
72948     try {
72949       (arg1)->Disable();
72950     } catch (std::out_of_range& e) {
72951       {
72952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72953       };
72954     } catch (std::exception& e) {
72955       {
72956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72957       };
72958     } catch (Dali::DaliException e) {
72959       {
72960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72961       };
72962     } catch (...) {
72963       {
72964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72965       };
72966     }
72967   }
72968
72969 }
72970
72971
72972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
72973   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72974   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
72975   Dali::Toolkit::RulerDomain *argp2 ;
72976
72977   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72978   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
72979   if (!argp2) {
72980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
72981     return ;
72982   }
72983   arg2 = *argp2;
72984   {
72985     try {
72986       (arg1)->SetDomain(arg2);
72987     } catch (std::out_of_range& e) {
72988       {
72989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72990       };
72991     } catch (std::exception& e) {
72992       {
72993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72994       };
72995     } catch (Dali::DaliException e) {
72996       {
72997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72998       };
72999     } catch (...) {
73000       {
73001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73002       };
73003     }
73004   }
73005
73006 }
73007
73008
73009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
73010   void * jresult ;
73011   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73012   Dali::Toolkit::RulerDomain *result = 0 ;
73013
73014   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73015   {
73016     try {
73017       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
73018     } catch (std::out_of_range& e) {
73019       {
73020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73021       };
73022     } catch (std::exception& e) {
73023       {
73024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73025       };
73026     } catch (Dali::DaliException e) {
73027       {
73028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73029       };
73030     } catch (...) {
73031       {
73032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73033       };
73034     }
73035   }
73036
73037   jresult = (void *)result;
73038   return jresult;
73039 }
73040
73041
73042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
73043   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73044
73045   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73046   {
73047     try {
73048       (arg1)->DisableDomain();
73049     } catch (std::out_of_range& e) {
73050       {
73051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73052       };
73053     } catch (std::exception& e) {
73054       {
73055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73056       };
73057     } catch (Dali::DaliException e) {
73058       {
73059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73060       };
73061     } catch (...) {
73062       {
73063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73064       };
73065     }
73066   }
73067
73068 }
73069
73070
73071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
73072   float jresult ;
73073   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73074   float arg2 ;
73075   float arg3 ;
73076   float arg4 ;
73077   float result;
73078
73079   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73080   arg2 = (float)jarg2;
73081   arg3 = (float)jarg3;
73082   arg4 = (float)jarg4;
73083   {
73084     try {
73085       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
73086     } catch (std::out_of_range& e) {
73087       {
73088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73089       };
73090     } catch (std::exception& e) {
73091       {
73092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73093       };
73094     } catch (Dali::DaliException e) {
73095       {
73096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73097       };
73098     } catch (...) {
73099       {
73100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73101       };
73102     }
73103   }
73104
73105   jresult = result;
73106   return jresult;
73107 }
73108
73109
73110 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73111   float jresult ;
73112   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73113   float arg2 ;
73114   float arg3 ;
73115   float result;
73116
73117   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73118   arg2 = (float)jarg2;
73119   arg3 = (float)jarg3;
73120   {
73121     try {
73122       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73123     } catch (std::out_of_range& e) {
73124       {
73125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73126       };
73127     } catch (std::exception& e) {
73128       {
73129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73130       };
73131     } catch (Dali::DaliException e) {
73132       {
73133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73134       };
73135     } catch (...) {
73136       {
73137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73138       };
73139     }
73140   }
73141
73142   jresult = result;
73143   return jresult;
73144 }
73145
73146
73147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73148   float jresult ;
73149   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73150   float arg2 ;
73151   float result;
73152
73153   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73154   arg2 = (float)jarg2;
73155   {
73156     try {
73157       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73158     } catch (std::out_of_range& e) {
73159       {
73160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73161       };
73162     } catch (std::exception& e) {
73163       {
73164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73165       };
73166     } catch (Dali::DaliException e) {
73167       {
73168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73169       };
73170     } catch (...) {
73171       {
73172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73173       };
73174     }
73175   }
73176
73177   jresult = result;
73178   return jresult;
73179 }
73180
73181
73182 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73183   float jresult ;
73184   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73185   float arg2 ;
73186   float arg3 ;
73187   float arg4 ;
73188   Dali::Toolkit::ClampState *arg5 = 0 ;
73189   float result;
73190
73191   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73192   arg2 = (float)jarg2;
73193   arg3 = (float)jarg3;
73194   arg4 = (float)jarg4;
73195   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73196   if (!arg5) {
73197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73198     return 0;
73199   }
73200   {
73201     try {
73202       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73203     } catch (std::out_of_range& e) {
73204       {
73205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73206       };
73207     } catch (std::exception& e) {
73208       {
73209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73210       };
73211     } catch (Dali::DaliException e) {
73212       {
73213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73214       };
73215     } catch (...) {
73216       {
73217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73218       };
73219     }
73220   }
73221
73222   jresult = result;
73223   return jresult;
73224 }
73225
73226
73227 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73228   float jresult ;
73229   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73230   float arg2 ;
73231   float arg3 ;
73232   float arg4 ;
73233   float arg5 ;
73234   float result;
73235
73236   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73237   arg2 = (float)jarg2;
73238   arg3 = (float)jarg3;
73239   arg4 = (float)jarg4;
73240   arg5 = (float)jarg5;
73241   {
73242     try {
73243       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73244     } catch (std::out_of_range& e) {
73245       {
73246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73247       };
73248     } catch (std::exception& e) {
73249       {
73250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73251       };
73252     } catch (Dali::DaliException e) {
73253       {
73254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73255       };
73256     } catch (...) {
73257       {
73258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73259       };
73260     }
73261   }
73262
73263   jresult = result;
73264   return jresult;
73265 }
73266
73267
73268 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73269   float jresult ;
73270   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73271   float arg2 ;
73272   float arg3 ;
73273   float arg4 ;
73274   float result;
73275
73276   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73277   arg2 = (float)jarg2;
73278   arg3 = (float)jarg3;
73279   arg4 = (float)jarg4;
73280   {
73281     try {
73282       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
73283     } catch (std::out_of_range& e) {
73284       {
73285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73286       };
73287     } catch (std::exception& e) {
73288       {
73289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73290       };
73291     } catch (Dali::DaliException e) {
73292       {
73293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73294       };
73295     } catch (...) {
73296       {
73297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73298       };
73299     }
73300   }
73301
73302   jresult = result;
73303   return jresult;
73304 }
73305
73306
73307 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73308   float jresult ;
73309   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73310   float arg2 ;
73311   float arg3 ;
73312   float result;
73313
73314   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73315   arg2 = (float)jarg2;
73316   arg3 = (float)jarg3;
73317   {
73318     try {
73319       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
73320     } catch (std::out_of_range& e) {
73321       {
73322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73323       };
73324     } catch (std::exception& e) {
73325       {
73326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73327       };
73328     } catch (Dali::DaliException e) {
73329       {
73330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73331       };
73332     } catch (...) {
73333       {
73334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73335       };
73336     }
73337   }
73338
73339   jresult = result;
73340   return jresult;
73341 }
73342
73343
73344 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73345   float jresult ;
73346   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73347   float arg2 ;
73348   float result;
73349
73350   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73351   arg2 = (float)jarg2;
73352   {
73353     try {
73354       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73355     } catch (std::out_of_range& e) {
73356       {
73357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73358       };
73359     } catch (std::exception& e) {
73360       {
73361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73362       };
73363     } catch (Dali::DaliException e) {
73364       {
73365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73366       };
73367     } catch (...) {
73368       {
73369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73370       };
73371     }
73372   }
73373
73374   jresult = result;
73375   return jresult;
73376 }
73377
73378
73379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73380   float jresult ;
73381   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73382   float arg2 ;
73383   float arg3 ;
73384   float arg4 ;
73385   float arg5 ;
73386   Dali::Toolkit::ClampState *arg6 = 0 ;
73387   float result;
73388
73389   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73390   arg2 = (float)jarg2;
73391   arg3 = (float)jarg3;
73392   arg4 = (float)jarg4;
73393   arg5 = (float)jarg5;
73394   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73395   if (!arg6) {
73396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73397     return 0;
73398   }
73399   {
73400     try {
73401       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73402     } catch (std::out_of_range& e) {
73403       {
73404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73405       };
73406     } catch (std::exception& e) {
73407       {
73408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73409       };
73410     } catch (Dali::DaliException e) {
73411       {
73412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73413       };
73414     } catch (...) {
73415       {
73416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73417       };
73418     }
73419   }
73420
73421   jresult = result;
73422   return jresult;
73423 }
73424
73425
73426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73427   void * jresult ;
73428   Dali::Toolkit::DefaultRuler *result = 0 ;
73429
73430   {
73431     try {
73432       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73433     } catch (std::out_of_range& e) {
73434       {
73435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73436       };
73437     } catch (std::exception& e) {
73438       {
73439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73440       };
73441     } catch (Dali::DaliException e) {
73442       {
73443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73444       };
73445     } catch (...) {
73446       {
73447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73448       };
73449     }
73450   }
73451
73452   jresult = (void *)result;
73453   return jresult;
73454 }
73455
73456
73457 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73458   float jresult ;
73459   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73460   float arg2 ;
73461   float arg3 ;
73462   float result;
73463
73464   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73465   arg2 = (float)jarg2;
73466   arg3 = (float)jarg3;
73467   {
73468     try {
73469       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73470     } catch (std::out_of_range& e) {
73471       {
73472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73473       };
73474     } catch (std::exception& e) {
73475       {
73476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73477       };
73478     } catch (Dali::DaliException e) {
73479       {
73480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73481       };
73482     } catch (...) {
73483       {
73484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73485       };
73486     }
73487   }
73488
73489   jresult = result;
73490   return jresult;
73491 }
73492
73493
73494 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73495   float jresult ;
73496   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73497   unsigned int arg2 ;
73498   unsigned int *arg3 = 0 ;
73499   bool arg4 ;
73500   float result;
73501
73502   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73503   arg2 = (unsigned int)jarg2;
73504   arg3 = (unsigned int *)jarg3;
73505   arg4 = jarg4 ? true : false;
73506   {
73507     try {
73508       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73509     } catch (std::out_of_range& e) {
73510       {
73511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73512       };
73513     } catch (std::exception& e) {
73514       {
73515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73516       };
73517     } catch (Dali::DaliException e) {
73518       {
73519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73520       };
73521     } catch (...) {
73522       {
73523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73524       };
73525     }
73526   }
73527
73528   jresult = result;
73529   return jresult;
73530 }
73531
73532
73533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73534   unsigned int jresult ;
73535   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73536   float arg2 ;
73537   bool arg3 ;
73538   unsigned int result;
73539
73540   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73541   arg2 = (float)jarg2;
73542   arg3 = jarg3 ? true : false;
73543   {
73544     try {
73545       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73546     } catch (std::out_of_range& e) {
73547       {
73548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73549       };
73550     } catch (std::exception& e) {
73551       {
73552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73553       };
73554     } catch (Dali::DaliException e) {
73555       {
73556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73557       };
73558     } catch (...) {
73559       {
73560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73561       };
73562     }
73563   }
73564
73565   jresult = result;
73566   return jresult;
73567 }
73568
73569
73570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73571   unsigned int jresult ;
73572   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73573   unsigned int result;
73574
73575   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73576   {
73577     try {
73578       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73579     } catch (std::out_of_range& e) {
73580       {
73581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73582       };
73583     } catch (std::exception& e) {
73584       {
73585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73586       };
73587     } catch (Dali::DaliException e) {
73588       {
73589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73590       };
73591     } catch (...) {
73592       {
73593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73594       };
73595     }
73596   }
73597
73598   jresult = result;
73599   return jresult;
73600 }
73601
73602
73603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73604   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73605
73606   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73607   {
73608     try {
73609       delete arg1;
73610     } catch (std::out_of_range& e) {
73611       {
73612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73613       };
73614     } catch (std::exception& e) {
73615       {
73616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73617       };
73618     } catch (Dali::DaliException e) {
73619       {
73620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73621       };
73622     } catch (...) {
73623       {
73624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73625       };
73626     }
73627   }
73628
73629 }
73630
73631
73632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73633   void * jresult ;
73634   float arg1 ;
73635   Dali::Toolkit::FixedRuler *result = 0 ;
73636
73637   arg1 = (float)jarg1;
73638   {
73639     try {
73640       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73641     } catch (std::out_of_range& e) {
73642       {
73643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73644       };
73645     } catch (std::exception& e) {
73646       {
73647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73648       };
73649     } catch (Dali::DaliException e) {
73650       {
73651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73652       };
73653     } catch (...) {
73654       {
73655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73656       };
73657     }
73658   }
73659
73660   jresult = (void *)result;
73661   return jresult;
73662 }
73663
73664
73665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
73666   void * jresult ;
73667   Dali::Toolkit::FixedRuler *result = 0 ;
73668
73669   {
73670     try {
73671       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
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 = (void *)result;
73692   return jresult;
73693 }
73694
73695
73696 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73697   float jresult ;
73698   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73699   float arg2 ;
73700   float arg3 ;
73701   float result;
73702
73703   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73704   arg2 = (float)jarg2;
73705   arg3 = (float)jarg3;
73706   {
73707     try {
73708       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73709     } catch (std::out_of_range& e) {
73710       {
73711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73712       };
73713     } catch (std::exception& e) {
73714       {
73715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73716       };
73717     } catch (Dali::DaliException e) {
73718       {
73719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73720       };
73721     } catch (...) {
73722       {
73723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73724       };
73725     }
73726   }
73727
73728   jresult = result;
73729   return jresult;
73730 }
73731
73732
73733 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73734   float jresult ;
73735   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73736   unsigned int arg2 ;
73737   unsigned int *arg3 = 0 ;
73738   bool arg4 ;
73739   float result;
73740
73741   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73742   arg2 = (unsigned int)jarg2;
73743   arg3 = (unsigned int *)jarg3;
73744   arg4 = jarg4 ? true : false;
73745   {
73746     try {
73747       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73748     } catch (std::out_of_range& e) {
73749       {
73750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73751       };
73752     } catch (std::exception& e) {
73753       {
73754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73755       };
73756     } catch (Dali::DaliException e) {
73757       {
73758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73759       };
73760     } catch (...) {
73761       {
73762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73763       };
73764     }
73765   }
73766
73767   jresult = result;
73768   return jresult;
73769 }
73770
73771
73772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73773   unsigned int jresult ;
73774   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73775   float arg2 ;
73776   bool arg3 ;
73777   unsigned int result;
73778
73779   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73780   arg2 = (float)jarg2;
73781   arg3 = jarg3 ? true : false;
73782   {
73783     try {
73784       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73785     } catch (std::out_of_range& e) {
73786       {
73787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73788       };
73789     } catch (std::exception& e) {
73790       {
73791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73792       };
73793     } catch (Dali::DaliException e) {
73794       {
73795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73796       };
73797     } catch (...) {
73798       {
73799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73800       };
73801     }
73802   }
73803
73804   jresult = result;
73805   return jresult;
73806 }
73807
73808
73809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
73810   unsigned int jresult ;
73811   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73812   unsigned int result;
73813
73814   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73815   {
73816     try {
73817       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
73818     } catch (std::out_of_range& e) {
73819       {
73820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73821       };
73822     } catch (std::exception& e) {
73823       {
73824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73825       };
73826     } catch (Dali::DaliException e) {
73827       {
73828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73829       };
73830     } catch (...) {
73831       {
73832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73833       };
73834     }
73835   }
73836
73837   jresult = result;
73838   return jresult;
73839 }
73840
73841
73842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
73843   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73844
73845   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73846   {
73847     try {
73848       delete arg1;
73849     } catch (std::out_of_range& e) {
73850       {
73851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73852       };
73853     } catch (std::exception& e) {
73854       {
73855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73856       };
73857     } catch (Dali::DaliException e) {
73858       {
73859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73860       };
73861     } catch (...) {
73862       {
73863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73864       };
73865     }
73866   }
73867
73868 }
73869
73870
73871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
73872   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73873   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73874
73875   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73876   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73877   if (arg1) (arg1)->scale = *arg2;
73878 }
73879
73880
73881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
73882   void * jresult ;
73883   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73884   Dali::Toolkit::ClampState2D *result = 0 ;
73885
73886   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73887   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
73888   jresult = (void *)result;
73889   return jresult;
73890 }
73891
73892
73893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
73894   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73895   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73896
73897   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73898   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73899   if (arg1) (arg1)->position = *arg2;
73900 }
73901
73902
73903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
73904   void * jresult ;
73905   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73906   Dali::Toolkit::ClampState2D *result = 0 ;
73907
73908   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73909   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
73910   jresult = (void *)result;
73911   return jresult;
73912 }
73913
73914
73915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
73916   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73917   Dali::Toolkit::ClampState arg2 ;
73918
73919   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73920   arg2 = (Dali::Toolkit::ClampState)jarg2;
73921   if (arg1) (arg1)->rotation = arg2;
73922 }
73923
73924
73925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
73926   int jresult ;
73927   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73928   Dali::Toolkit::ClampState result;
73929
73930   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73931   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
73932   jresult = (int)result;
73933   return jresult;
73934 }
73935
73936
73937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
73938   void * jresult ;
73939   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
73940
73941   {
73942     try {
73943       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
73944     } catch (std::out_of_range& e) {
73945       {
73946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73947       };
73948     } catch (std::exception& e) {
73949       {
73950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73951       };
73952     } catch (Dali::DaliException e) {
73953       {
73954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73955       };
73956     } catch (...) {
73957       {
73958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73959       };
73960     }
73961   }
73962
73963   jresult = (void *)result;
73964   return jresult;
73965 }
73966
73967
73968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
73969   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73970
73971   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73972   {
73973     try {
73974       delete arg1;
73975     } catch (std::out_of_range& e) {
73976       {
73977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73978       };
73979     } catch (std::exception& e) {
73980       {
73981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73982       };
73983     } catch (Dali::DaliException e) {
73984       {
73985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73986       };
73987     } catch (...) {
73988       {
73989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73990       };
73991     }
73992   }
73993
73994 }
73995
73996
73997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
73998   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73999   Dali::Toolkit::SnapType arg2 ;
74000
74001   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74002   arg2 = (Dali::Toolkit::SnapType)jarg2;
74003   if (arg1) (arg1)->type = arg2;
74004 }
74005
74006
74007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
74008   int jresult ;
74009   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74010   Dali::Toolkit::SnapType result;
74011
74012   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74013   result = (Dali::Toolkit::SnapType) ((arg1)->type);
74014   jresult = (int)result;
74015   return jresult;
74016 }
74017
74018
74019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
74020   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74021   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
74022
74023   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74024   arg2 = (Dali::Vector2 *)jarg2;
74025   if (arg1) (arg1)->position = *arg2;
74026 }
74027
74028
74029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
74030   void * jresult ;
74031   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74032   Dali::Vector2 *result = 0 ;
74033
74034   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74035   result = (Dali::Vector2 *)& ((arg1)->position);
74036   jresult = (void *)result;
74037   return jresult;
74038 }
74039
74040
74041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
74042   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74043   float arg2 ;
74044
74045   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74046   arg2 = (float)jarg2;
74047   if (arg1) (arg1)->duration = arg2;
74048 }
74049
74050
74051 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
74052   float jresult ;
74053   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74054   float result;
74055
74056   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74057   result = (float) ((arg1)->duration);
74058   jresult = result;
74059   return jresult;
74060 }
74061
74062
74063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
74064   void * jresult ;
74065   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
74066
74067   {
74068     try {
74069       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
74070     } catch (std::out_of_range& e) {
74071       {
74072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74073       };
74074     } catch (std::exception& e) {
74075       {
74076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74077       };
74078     } catch (Dali::DaliException e) {
74079       {
74080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74081       };
74082     } catch (...) {
74083       {
74084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74085       };
74086     }
74087   }
74088
74089   jresult = (void *)result;
74090   return jresult;
74091 }
74092
74093
74094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
74095   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74096
74097   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74098   {
74099     try {
74100       delete arg1;
74101     } catch (std::out_of_range& e) {
74102       {
74103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74104       };
74105     } catch (std::exception& e) {
74106       {
74107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74108       };
74109     } catch (Dali::DaliException e) {
74110       {
74111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74112       };
74113     } catch (...) {
74114       {
74115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74116       };
74117     }
74118   }
74119
74120 }
74121
74122
74123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
74124   int jresult ;
74125   int result;
74126
74127   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
74128   jresult = (int)result;
74129   return jresult;
74130 }
74131
74132
74133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
74134   int jresult ;
74135   int result;
74136
74137   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
74138   jresult = (int)result;
74139   return jresult;
74140 }
74141
74142
74143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
74144   int jresult ;
74145   int result;
74146
74147   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
74148   jresult = (int)result;
74149   return jresult;
74150 }
74151
74152
74153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74154   int jresult ;
74155   int result;
74156
74157   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74158   jresult = (int)result;
74159   return jresult;
74160 }
74161
74162
74163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
74164   int jresult ;
74165   int result;
74166
74167   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
74168   jresult = (int)result;
74169   return jresult;
74170 }
74171
74172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
74173   int jresult ;
74174   int result;
74175
74176   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
74177   jresult = (int)result;
74178   return jresult;
74179 }
74180
74181
74182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
74183   int jresult ;
74184   int result;
74185
74186   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
74187   jresult = (int)result;
74188   return jresult;
74189 }
74190
74191
74192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
74193   int jresult ;
74194   int result;
74195
74196   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
74197   jresult = (int)result;
74198   return jresult;
74199 }
74200
74201
74202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
74203   int jresult ;
74204   int result;
74205
74206   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
74207   jresult = (int)result;
74208   return jresult;
74209 }
74210
74211
74212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74213   int jresult ;
74214   int result;
74215
74216   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74217   jresult = (int)result;
74218   return jresult;
74219 }
74220
74221
74222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74223   int jresult ;
74224   int result;
74225
74226   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74227   jresult = (int)result;
74228   return jresult;
74229 }
74230
74231
74232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74233   int jresult ;
74234   int result;
74235
74236   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74237   jresult = (int)result;
74238   return jresult;
74239 }
74240
74241
74242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74243   int jresult ;
74244   int result;
74245
74246   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74247   jresult = (int)result;
74248   return jresult;
74249 }
74250
74251
74252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74253   int jresult ;
74254   int result;
74255
74256   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74257   jresult = (int)result;
74258   return jresult;
74259 }
74260
74261
74262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74263   int jresult ;
74264   int result;
74265
74266   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74267   jresult = (int)result;
74268   return jresult;
74269 }
74270
74271
74272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74273   int jresult ;
74274   int result;
74275
74276   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74277   jresult = (int)result;
74278   return jresult;
74279 }
74280
74281
74282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74283   int jresult ;
74284   int result;
74285
74286   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74287   jresult = (int)result;
74288   return jresult;
74289 }
74290
74291
74292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74293   int jresult ;
74294   int result;
74295
74296   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74297   jresult = (int)result;
74298   return jresult;
74299 }
74300
74301
74302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74303   int jresult ;
74304   int result;
74305
74306   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74307   jresult = (int)result;
74308   return jresult;
74309 }
74310
74311
74312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74313   int jresult ;
74314   int result;
74315
74316   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74317   jresult = (int)result;
74318   return jresult;
74319 }
74320
74321
74322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74323   int jresult ;
74324   int result;
74325
74326   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74327   jresult = (int)result;
74328   return jresult;
74329 }
74330
74331
74332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74333   int jresult ;
74334   int result;
74335
74336   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74337   jresult = (int)result;
74338   return jresult;
74339 }
74340
74341
74342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74343   int jresult ;
74344   int result;
74345
74346   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74347   jresult = (int)result;
74348   return jresult;
74349 }
74350
74351
74352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74353   int jresult ;
74354   int result;
74355
74356   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74357   jresult = (int)result;
74358   return jresult;
74359 }
74360
74361
74362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74363   int jresult ;
74364   int result;
74365
74366   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74367   jresult = (int)result;
74368   return jresult;
74369 }
74370
74371
74372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74373   int jresult ;
74374   int result;
74375
74376   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74377   jresult = (int)result;
74378   return jresult;
74379 }
74380
74381
74382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74383   void * jresult ;
74384   Dali::Toolkit::ScrollView::Property *result = 0 ;
74385
74386   {
74387     try {
74388       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74389     } catch (std::out_of_range& e) {
74390       {
74391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74392       };
74393     } catch (std::exception& e) {
74394       {
74395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74396       };
74397     } catch (Dali::DaliException e) {
74398       {
74399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74400       };
74401     } catch (...) {
74402       {
74403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74404       };
74405     }
74406   }
74407
74408   jresult = (void *)result;
74409   return jresult;
74410 }
74411
74412
74413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74414   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74415
74416   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74417   {
74418     try {
74419       delete arg1;
74420     } catch (std::out_of_range& e) {
74421       {
74422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74423       };
74424     } catch (std::exception& e) {
74425       {
74426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74427       };
74428     } catch (Dali::DaliException e) {
74429       {
74430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74431       };
74432     } catch (...) {
74433       {
74434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74435       };
74436     }
74437   }
74438
74439 }
74440
74441
74442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74443   void * jresult ;
74444   Dali::Toolkit::ScrollView *result = 0 ;
74445
74446   {
74447     try {
74448       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74449     } catch (std::out_of_range& e) {
74450       {
74451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74452       };
74453     } catch (std::exception& e) {
74454       {
74455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74456       };
74457     } catch (Dali::DaliException e) {
74458       {
74459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74460       };
74461     } catch (...) {
74462       {
74463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74464       };
74465     }
74466   }
74467
74468   jresult = (void *)result;
74469   return jresult;
74470 }
74471
74472
74473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74474   void * jresult ;
74475   Dali::Toolkit::ScrollView *arg1 = 0 ;
74476   Dali::Toolkit::ScrollView *result = 0 ;
74477
74478   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74479   if (!arg1) {
74480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74481     return 0;
74482   }
74483   {
74484     try {
74485       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74486     } catch (std::out_of_range& e) {
74487       {
74488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74489       };
74490     } catch (std::exception& e) {
74491       {
74492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74493       };
74494     } catch (Dali::DaliException e) {
74495       {
74496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74497       };
74498     } catch (...) {
74499       {
74500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74501       };
74502     }
74503   }
74504
74505   jresult = (void *)result;
74506   return jresult;
74507 }
74508
74509
74510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74511   void * jresult ;
74512   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74513   Dali::Toolkit::ScrollView *arg2 = 0 ;
74514   Dali::Toolkit::ScrollView *result = 0 ;
74515
74516   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74517   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74518   if (!arg2) {
74519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74520     return 0;
74521   }
74522   {
74523     try {
74524       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74525     } catch (std::out_of_range& e) {
74526       {
74527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74528       };
74529     } catch (std::exception& e) {
74530       {
74531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74532       };
74533     } catch (Dali::DaliException e) {
74534       {
74535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74536       };
74537     } catch (...) {
74538       {
74539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74540       };
74541     }
74542   }
74543
74544   jresult = (void *)result;
74545   return jresult;
74546 }
74547
74548
74549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74550   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74551
74552   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74553   {
74554     try {
74555       delete arg1;
74556     } catch (std::out_of_range& e) {
74557       {
74558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74559       };
74560     } catch (std::exception& e) {
74561       {
74562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74563       };
74564     } catch (Dali::DaliException e) {
74565       {
74566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74567       };
74568     } catch (...) {
74569       {
74570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74571       };
74572     }
74573   }
74574
74575 }
74576
74577
74578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74579   void * jresult ;
74580   Dali::Toolkit::ScrollView result;
74581
74582   {
74583     try {
74584       result = Dali::Toolkit::ScrollView::New();
74585     } catch (std::out_of_range& e) {
74586       {
74587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74588       };
74589     } catch (std::exception& e) {
74590       {
74591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74592       };
74593     } catch (Dali::DaliException e) {
74594       {
74595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74596       };
74597     } catch (...) {
74598       {
74599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74600       };
74601     }
74602   }
74603
74604   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74605   return jresult;
74606 }
74607
74608
74609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74610   void * jresult ;
74611   Dali::BaseHandle arg1 ;
74612   Dali::BaseHandle *argp1 ;
74613   Dali::Toolkit::ScrollView result;
74614
74615   argp1 = (Dali::BaseHandle *)jarg1;
74616   if (!argp1) {
74617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74618     return 0;
74619   }
74620   arg1 = *argp1;
74621   {
74622     try {
74623       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74624     } catch (std::out_of_range& e) {
74625       {
74626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74627       };
74628     } catch (std::exception& e) {
74629       {
74630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74631       };
74632     } catch (Dali::DaliException e) {
74633       {
74634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74635       };
74636     } catch (...) {
74637       {
74638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74639       };
74640     }
74641   }
74642
74643   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74644   return jresult;
74645 }
74646
74647
74648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74649   void * jresult ;
74650   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74651   Dali::AlphaFunction result;
74652
74653   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74654   {
74655     try {
74656       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74657     } catch (std::out_of_range& e) {
74658       {
74659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74660       };
74661     } catch (std::exception& e) {
74662       {
74663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74664       };
74665     } catch (Dali::DaliException e) {
74666       {
74667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74668       };
74669     } catch (...) {
74670       {
74671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74672       };
74673     }
74674   }
74675
74676   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74677   return jresult;
74678 }
74679
74680
74681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74682   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74683   Dali::AlphaFunction arg2 ;
74684   Dali::AlphaFunction *argp2 ;
74685
74686   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74687   argp2 = (Dali::AlphaFunction *)jarg2;
74688   if (!argp2) {
74689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74690     return ;
74691   }
74692   arg2 = *argp2;
74693   {
74694     try {
74695       (arg1)->SetScrollSnapAlphaFunction(arg2);
74696     } catch (std::out_of_range& e) {
74697       {
74698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74699       };
74700     } catch (std::exception& e) {
74701       {
74702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74703       };
74704     } catch (Dali::DaliException e) {
74705       {
74706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74707       };
74708     } catch (...) {
74709       {
74710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74711       };
74712     }
74713   }
74714
74715 }
74716
74717
74718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74719   void * jresult ;
74720   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74721   Dali::AlphaFunction result;
74722
74723   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74724   {
74725     try {
74726       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
74727     } catch (std::out_of_range& e) {
74728       {
74729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74730       };
74731     } catch (std::exception& e) {
74732       {
74733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74734       };
74735     } catch (Dali::DaliException e) {
74736       {
74737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74738       };
74739     } catch (...) {
74740       {
74741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74742       };
74743     }
74744   }
74745
74746   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74747   return jresult;
74748 }
74749
74750
74751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74752   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74753   Dali::AlphaFunction arg2 ;
74754   Dali::AlphaFunction *argp2 ;
74755
74756   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74757   argp2 = (Dali::AlphaFunction *)jarg2;
74758   if (!argp2) {
74759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74760     return ;
74761   }
74762   arg2 = *argp2;
74763   {
74764     try {
74765       (arg1)->SetScrollFlickAlphaFunction(arg2);
74766     } catch (std::out_of_range& e) {
74767       {
74768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74769       };
74770     } catch (std::exception& e) {
74771       {
74772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74773       };
74774     } catch (Dali::DaliException e) {
74775       {
74776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74777       };
74778     } catch (...) {
74779       {
74780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74781       };
74782     }
74783   }
74784
74785 }
74786
74787
74788 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
74789   float jresult ;
74790   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74791   float result;
74792
74793   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74794   {
74795     try {
74796       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
74797     } catch (std::out_of_range& e) {
74798       {
74799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74800       };
74801     } catch (std::exception& e) {
74802       {
74803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74804       };
74805     } catch (Dali::DaliException e) {
74806       {
74807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74808       };
74809     } catch (...) {
74810       {
74811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74812       };
74813     }
74814   }
74815
74816   jresult = result;
74817   return jresult;
74818 }
74819
74820
74821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
74822   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74823   float arg2 ;
74824
74825   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74826   arg2 = (float)jarg2;
74827   {
74828     try {
74829       (arg1)->SetScrollSnapDuration(arg2);
74830     } catch (std::out_of_range& e) {
74831       {
74832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74833       };
74834     } catch (std::exception& e) {
74835       {
74836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74837       };
74838     } catch (Dali::DaliException e) {
74839       {
74840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74841       };
74842     } catch (...) {
74843       {
74844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74845       };
74846     }
74847   }
74848
74849 }
74850
74851
74852 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
74853   float jresult ;
74854   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74855   float result;
74856
74857   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74858   {
74859     try {
74860       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
74861     } catch (std::out_of_range& e) {
74862       {
74863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74864       };
74865     } catch (std::exception& e) {
74866       {
74867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74868       };
74869     } catch (Dali::DaliException e) {
74870       {
74871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74872       };
74873     } catch (...) {
74874       {
74875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74876       };
74877     }
74878   }
74879
74880   jresult = result;
74881   return jresult;
74882 }
74883
74884
74885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
74886   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74887   float arg2 ;
74888
74889   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74890   arg2 = (float)jarg2;
74891   {
74892     try {
74893       (arg1)->SetScrollFlickDuration(arg2);
74894     } catch (std::out_of_range& e) {
74895       {
74896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74897       };
74898     } catch (std::exception& e) {
74899       {
74900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74901       };
74902     } catch (Dali::DaliException e) {
74903       {
74904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74905       };
74906     } catch (...) {
74907       {
74908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74909       };
74910     }
74911   }
74912
74913 }
74914
74915
74916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
74917   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74918   Dali::Toolkit::RulerPtr arg2 ;
74919   Dali::Toolkit::RulerPtr *argp2 ;
74920
74921   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74922   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74923   if (!argp2) {
74924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74925     return ;
74926   }
74927   arg2 = *argp2;
74928   {
74929     try {
74930       (arg1)->SetRulerX(arg2);
74931     } catch (std::out_of_range& e) {
74932       {
74933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74934       };
74935     } catch (std::exception& e) {
74936       {
74937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74938       };
74939     } catch (Dali::DaliException e) {
74940       {
74941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74942       };
74943     } catch (...) {
74944       {
74945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74946       };
74947     }
74948   }
74949
74950 }
74951
74952
74953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
74954   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74955   Dali::Toolkit::RulerPtr arg2 ;
74956   Dali::Toolkit::RulerPtr *argp2 ;
74957
74958   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74959   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74960   if (!argp2) {
74961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74962     return ;
74963   }
74964   arg2 = *argp2;
74965   {
74966     try {
74967       (arg1)->SetRulerY(arg2);
74968     } catch (std::out_of_range& e) {
74969       {
74970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74971       };
74972     } catch (std::exception& e) {
74973       {
74974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74975       };
74976     } catch (Dali::DaliException e) {
74977       {
74978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74979       };
74980     } catch (...) {
74981       {
74982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74983       };
74984     }
74985   }
74986
74987 }
74988
74989
74990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
74991   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74992   bool arg2 ;
74993
74994   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74995   arg2 = jarg2 ? true : false;
74996   {
74997     try {
74998       (arg1)->SetScrollSensitive(arg2);
74999     } catch (std::out_of_range& e) {
75000       {
75001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75002       };
75003     } catch (std::exception& e) {
75004       {
75005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75006       };
75007     } catch (Dali::DaliException e) {
75008       {
75009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75010       };
75011     } catch (...) {
75012       {
75013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75014       };
75015     }
75016   }
75017
75018 }
75019
75020
75021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
75022   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75023   float arg2 ;
75024   float arg3 ;
75025
75026   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75027   arg2 = (float)jarg2;
75028   arg3 = (float)jarg3;
75029   {
75030     try {
75031       (arg1)->SetMaxOvershoot(arg2,arg3);
75032     } catch (std::out_of_range& e) {
75033       {
75034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75035       };
75036     } catch (std::exception& e) {
75037       {
75038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75039       };
75040     } catch (Dali::DaliException e) {
75041       {
75042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75043       };
75044     } catch (...) {
75045       {
75046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75047       };
75048     }
75049   }
75050
75051 }
75052
75053
75054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
75055   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75056   Dali::AlphaFunction arg2 ;
75057   Dali::AlphaFunction *argp2 ;
75058
75059   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75060   argp2 = (Dali::AlphaFunction *)jarg2;
75061   if (!argp2) {
75062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75063     return ;
75064   }
75065   arg2 = *argp2;
75066   {
75067     try {
75068       (arg1)->SetSnapOvershootAlphaFunction(arg2);
75069     } catch (std::out_of_range& e) {
75070       {
75071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75072       };
75073     } catch (std::exception& e) {
75074       {
75075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75076       };
75077     } catch (Dali::DaliException e) {
75078       {
75079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75080       };
75081     } catch (...) {
75082       {
75083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75084       };
75085     }
75086   }
75087
75088 }
75089
75090
75091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
75092   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75093   float arg2 ;
75094
75095   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75096   arg2 = (float)jarg2;
75097   {
75098     try {
75099       (arg1)->SetSnapOvershootDuration(arg2);
75100     } catch (std::out_of_range& e) {
75101       {
75102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75103       };
75104     } catch (std::exception& e) {
75105       {
75106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75107       };
75108     } catch (Dali::DaliException e) {
75109       {
75110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75111       };
75112     } catch (...) {
75113       {
75114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75115       };
75116     }
75117   }
75118
75119 }
75120
75121
75122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
75123   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75124   bool arg2 ;
75125
75126   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75127   arg2 = jarg2 ? true : false;
75128   {
75129     try {
75130       (arg1)->SetActorAutoSnap(arg2);
75131     } catch (std::out_of_range& e) {
75132       {
75133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75134       };
75135     } catch (std::exception& e) {
75136       {
75137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75138       };
75139     } catch (Dali::DaliException e) {
75140       {
75141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75142       };
75143     } catch (...) {
75144       {
75145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75146       };
75147     }
75148   }
75149
75150 }
75151
75152
75153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
75154   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75155   bool arg2 ;
75156
75157   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75158   arg2 = jarg2 ? true : false;
75159   {
75160     try {
75161       (arg1)->SetWrapMode(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 int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
75185   int jresult ;
75186   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75187   int result;
75188
75189   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75190   {
75191     try {
75192       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
75193     } catch (std::out_of_range& e) {
75194       {
75195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75196       };
75197     } catch (std::exception& e) {
75198       {
75199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75200       };
75201     } catch (Dali::DaliException e) {
75202       {
75203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75204       };
75205     } catch (...) {
75206       {
75207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75208       };
75209     }
75210   }
75211
75212   jresult = result;
75213   return jresult;
75214 }
75215
75216
75217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
75218   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75219   int arg2 ;
75220
75221   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75222   arg2 = (int)jarg2;
75223   {
75224     try {
75225       (arg1)->SetScrollUpdateDistance(arg2);
75226     } catch (std::out_of_range& e) {
75227       {
75228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75229       };
75230     } catch (std::exception& e) {
75231       {
75232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75233       };
75234     } catch (Dali::DaliException e) {
75235       {
75236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75237       };
75238     } catch (...) {
75239       {
75240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75241       };
75242     }
75243   }
75244
75245 }
75246
75247
75248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
75249   unsigned int jresult ;
75250   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75251   bool result;
75252
75253   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75254   {
75255     try {
75256       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
75257     } catch (std::out_of_range& e) {
75258       {
75259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75260       };
75261     } catch (std::exception& e) {
75262       {
75263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75264       };
75265     } catch (Dali::DaliException e) {
75266       {
75267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75268       };
75269     } catch (...) {
75270       {
75271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75272       };
75273     }
75274   }
75275
75276   jresult = result;
75277   return jresult;
75278 }
75279
75280
75281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
75282   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75283   bool arg2 ;
75284
75285   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75286   arg2 = jarg2 ? true : false;
75287   {
75288     try {
75289       (arg1)->SetAxisAutoLock(arg2);
75290     } catch (std::out_of_range& e) {
75291       {
75292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75293       };
75294     } catch (std::exception& e) {
75295       {
75296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75297       };
75298     } catch (Dali::DaliException e) {
75299       {
75300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75301       };
75302     } catch (...) {
75303       {
75304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75305       };
75306     }
75307   }
75308
75309 }
75310
75311
75312 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
75313   float jresult ;
75314   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75315   float result;
75316
75317   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75318   {
75319     try {
75320       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
75321     } catch (std::out_of_range& e) {
75322       {
75323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75324       };
75325     } catch (std::exception& e) {
75326       {
75327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75328       };
75329     } catch (Dali::DaliException e) {
75330       {
75331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75332       };
75333     } catch (...) {
75334       {
75335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75336       };
75337     }
75338   }
75339
75340   jresult = result;
75341   return jresult;
75342 }
75343
75344
75345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
75346   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75347   float arg2 ;
75348
75349   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75350   arg2 = (float)jarg2;
75351   {
75352     try {
75353       (arg1)->SetAxisAutoLockGradient(arg2);
75354     } catch (std::out_of_range& e) {
75355       {
75356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75357       };
75358     } catch (std::exception& e) {
75359       {
75360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75361       };
75362     } catch (Dali::DaliException e) {
75363       {
75364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75365       };
75366     } catch (...) {
75367       {
75368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75369       };
75370     }
75371   }
75372
75373 }
75374
75375
75376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
75377   float jresult ;
75378   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75379   float result;
75380
75381   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75382   {
75383     try {
75384       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75385     } catch (std::out_of_range& e) {
75386       {
75387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75388       };
75389     } catch (std::exception& e) {
75390       {
75391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75392       };
75393     } catch (Dali::DaliException e) {
75394       {
75395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75396       };
75397     } catch (...) {
75398       {
75399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75400       };
75401     }
75402   }
75403
75404   jresult = result;
75405   return jresult;
75406 }
75407
75408
75409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75410   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75411   float arg2 ;
75412
75413   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75414   arg2 = (float)jarg2;
75415   {
75416     try {
75417       (arg1)->SetFrictionCoefficient(arg2);
75418     } catch (std::out_of_range& e) {
75419       {
75420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75421       };
75422     } catch (std::exception& e) {
75423       {
75424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75425       };
75426     } catch (Dali::DaliException e) {
75427       {
75428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75429       };
75430     } catch (...) {
75431       {
75432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75433       };
75434     }
75435   }
75436
75437 }
75438
75439
75440 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75441   float jresult ;
75442   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75443   float result;
75444
75445   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75446   {
75447     try {
75448       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75449     } catch (std::out_of_range& e) {
75450       {
75451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75452       };
75453     } catch (std::exception& e) {
75454       {
75455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75456       };
75457     } catch (Dali::DaliException e) {
75458       {
75459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75460       };
75461     } catch (...) {
75462       {
75463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75464       };
75465     }
75466   }
75467
75468   jresult = result;
75469   return jresult;
75470 }
75471
75472
75473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75474   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75475   float arg2 ;
75476
75477   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75478   arg2 = (float)jarg2;
75479   {
75480     try {
75481       (arg1)->SetFlickSpeedCoefficient(arg2);
75482     } catch (std::out_of_range& e) {
75483       {
75484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75485       };
75486     } catch (std::exception& e) {
75487       {
75488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75489       };
75490     } catch (Dali::DaliException e) {
75491       {
75492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75493       };
75494     } catch (...) {
75495       {
75496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75497       };
75498     }
75499   }
75500
75501 }
75502
75503
75504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75505   void * jresult ;
75506   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75507   Dali::Vector2 result;
75508
75509   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75510   {
75511     try {
75512       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75513     } catch (std::out_of_range& e) {
75514       {
75515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75516       };
75517     } catch (std::exception& e) {
75518       {
75519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75520       };
75521     } catch (Dali::DaliException e) {
75522       {
75523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75524       };
75525     } catch (...) {
75526       {
75527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75528       };
75529     }
75530   }
75531
75532   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75533   return jresult;
75534 }
75535
75536
75537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75538   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75539   Dali::Vector2 *arg2 = 0 ;
75540
75541   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75542   arg2 = (Dali::Vector2 *)jarg2;
75543   if (!arg2) {
75544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75545     return ;
75546   }
75547   {
75548     try {
75549       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75550     } catch (std::out_of_range& e) {
75551       {
75552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75553       };
75554     } catch (std::exception& e) {
75555       {
75556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75557       };
75558     } catch (Dali::DaliException e) {
75559       {
75560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75561       };
75562     } catch (...) {
75563       {
75564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75565       };
75566     }
75567   }
75568
75569 }
75570
75571
75572 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75573   float jresult ;
75574   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75575   float result;
75576
75577   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75578   {
75579     try {
75580       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75581     } catch (std::out_of_range& e) {
75582       {
75583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75584       };
75585     } catch (std::exception& e) {
75586       {
75587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75588       };
75589     } catch (Dali::DaliException e) {
75590       {
75591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75592       };
75593     } catch (...) {
75594       {
75595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75596       };
75597     }
75598   }
75599
75600   jresult = result;
75601   return jresult;
75602 }
75603
75604
75605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75606   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75607   float arg2 ;
75608
75609   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75610   arg2 = (float)jarg2;
75611   {
75612     try {
75613       (arg1)->SetMinimumSpeedForFlick(arg2);
75614     } catch (std::out_of_range& e) {
75615       {
75616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75617       };
75618     } catch (std::exception& e) {
75619       {
75620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75621       };
75622     } catch (Dali::DaliException e) {
75623       {
75624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75625       };
75626     } catch (...) {
75627       {
75628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75629       };
75630     }
75631   }
75632
75633 }
75634
75635
75636 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75637   float jresult ;
75638   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75639   float result;
75640
75641   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75642   {
75643     try {
75644       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
75645     } catch (std::out_of_range& e) {
75646       {
75647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75648       };
75649     } catch (std::exception& e) {
75650       {
75651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75652       };
75653     } catch (Dali::DaliException e) {
75654       {
75655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75656       };
75657     } catch (...) {
75658       {
75659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75660       };
75661     }
75662   }
75663
75664   jresult = result;
75665   return jresult;
75666 }
75667
75668
75669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75670   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75671   float arg2 ;
75672
75673   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75674   arg2 = (float)jarg2;
75675   {
75676     try {
75677       (arg1)->SetMaxFlickSpeed(arg2);
75678     } catch (std::out_of_range& e) {
75679       {
75680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75681       };
75682     } catch (std::exception& e) {
75683       {
75684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75685       };
75686     } catch (Dali::DaliException e) {
75687       {
75688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75689       };
75690     } catch (...) {
75691       {
75692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75693       };
75694     }
75695   }
75696
75697 }
75698
75699
75700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75701   void * jresult ;
75702   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75703   Dali::Vector2 result;
75704
75705   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75706   {
75707     try {
75708       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75709     } catch (std::out_of_range& e) {
75710       {
75711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75712       };
75713     } catch (std::exception& e) {
75714       {
75715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75716       };
75717     } catch (Dali::DaliException e) {
75718       {
75719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75720       };
75721     } catch (...) {
75722       {
75723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75724       };
75725     }
75726   }
75727
75728   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75729   return jresult;
75730 }
75731
75732
75733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75734   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75735   Dali::Vector2 arg2 ;
75736   Dali::Vector2 *argp2 ;
75737
75738   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75739   argp2 = (Dali::Vector2 *)jarg2;
75740   if (!argp2) {
75741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75742     return ;
75743   }
75744   arg2 = *argp2;
75745   {
75746     try {
75747       (arg1)->SetWheelScrollDistanceStep(arg2);
75748     } catch (std::out_of_range& e) {
75749       {
75750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75751       };
75752     } catch (std::exception& e) {
75753       {
75754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75755       };
75756     } catch (Dali::DaliException e) {
75757       {
75758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75759       };
75760     } catch (...) {
75761       {
75762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75763       };
75764     }
75765   }
75766
75767 }
75768
75769
75770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
75771   void * jresult ;
75772   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75773   Dali::Vector2 result;
75774
75775   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75776   {
75777     try {
75778       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
75779     } catch (std::out_of_range& e) {
75780       {
75781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75782       };
75783     } catch (std::exception& e) {
75784       {
75785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75786       };
75787     } catch (Dali::DaliException e) {
75788       {
75789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75790       };
75791     } catch (...) {
75792       {
75793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75794       };
75795     }
75796   }
75797
75798   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75799   return jresult;
75800 }
75801
75802
75803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
75804   unsigned int jresult ;
75805   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75806   unsigned int result;
75807
75808   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75809   {
75810     try {
75811       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
75812     } catch (std::out_of_range& e) {
75813       {
75814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75815       };
75816     } catch (std::exception& e) {
75817       {
75818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75819       };
75820     } catch (Dali::DaliException e) {
75821       {
75822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75823       };
75824     } catch (...) {
75825       {
75826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75827       };
75828     }
75829   }
75830
75831   jresult = result;
75832   return jresult;
75833 }
75834
75835
75836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
75837   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75838   Dali::Vector2 *arg2 = 0 ;
75839
75840   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75841   arg2 = (Dali::Vector2 *)jarg2;
75842   if (!arg2) {
75843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75844     return ;
75845   }
75846   {
75847     try {
75848       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
75849     } catch (std::out_of_range& e) {
75850       {
75851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75852       };
75853     } catch (std::exception& e) {
75854       {
75855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75856       };
75857     } catch (Dali::DaliException e) {
75858       {
75859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75860       };
75861     } catch (...) {
75862       {
75863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75864       };
75865     }
75866   }
75867
75868 }
75869
75870
75871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
75872   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75873   Dali::Vector2 *arg2 = 0 ;
75874   float arg3 ;
75875
75876   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75877   arg2 = (Dali::Vector2 *)jarg2;
75878   if (!arg2) {
75879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75880     return ;
75881   }
75882   arg3 = (float)jarg3;
75883   {
75884     try {
75885       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
75886     } catch (std::out_of_range& e) {
75887       {
75888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75889       };
75890     } catch (std::exception& e) {
75891       {
75892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75893       };
75894     } catch (Dali::DaliException e) {
75895       {
75896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75897       };
75898     } catch (...) {
75899       {
75900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75901       };
75902     }
75903   }
75904
75905 }
75906
75907
75908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
75909   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75910   Dali::Vector2 *arg2 = 0 ;
75911   float arg3 ;
75912   Dali::AlphaFunction arg4 ;
75913   Dali::AlphaFunction *argp4 ;
75914
75915   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75916   arg2 = (Dali::Vector2 *)jarg2;
75917   if (!arg2) {
75918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75919     return ;
75920   }
75921   arg3 = (float)jarg3;
75922   argp4 = (Dali::AlphaFunction *)jarg4;
75923   if (!argp4) {
75924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75925     return ;
75926   }
75927   arg4 = *argp4;
75928   {
75929     try {
75930       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
75931     } catch (std::out_of_range& e) {
75932       {
75933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75934       };
75935     } catch (std::exception& e) {
75936       {
75937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75938       };
75939     } catch (Dali::DaliException e) {
75940       {
75941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75942       };
75943     } catch (...) {
75944       {
75945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75946       };
75947     }
75948   }
75949
75950 }
75951
75952
75953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
75954   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75955   Dali::Vector2 *arg2 = 0 ;
75956   float arg3 ;
75957   Dali::Toolkit::DirectionBias arg4 ;
75958   Dali::Toolkit::DirectionBias arg5 ;
75959
75960   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75961   arg2 = (Dali::Vector2 *)jarg2;
75962   if (!arg2) {
75963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75964     return ;
75965   }
75966   arg3 = (float)jarg3;
75967   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75968   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75969   {
75970     try {
75971       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
75972     } catch (std::out_of_range& e) {
75973       {
75974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75975       };
75976     } catch (std::exception& e) {
75977       {
75978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75979       };
75980     } catch (Dali::DaliException e) {
75981       {
75982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75983       };
75984     } catch (...) {
75985       {
75986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75987       };
75988     }
75989   }
75990
75991 }
75992
75993
75994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
75995   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75996   Dali::Vector2 *arg2 = 0 ;
75997   float arg3 ;
75998   Dali::AlphaFunction arg4 ;
75999   Dali::Toolkit::DirectionBias arg5 ;
76000   Dali::Toolkit::DirectionBias arg6 ;
76001   Dali::AlphaFunction *argp4 ;
76002
76003   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76004   arg2 = (Dali::Vector2 *)jarg2;
76005   if (!arg2) {
76006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76007     return ;
76008   }
76009   arg3 = (float)jarg3;
76010   argp4 = (Dali::AlphaFunction *)jarg4;
76011   if (!argp4) {
76012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76013     return ;
76014   }
76015   arg4 = *argp4;
76016   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76017   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
76018   {
76019     try {
76020       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
76021     } catch (std::out_of_range& e) {
76022       {
76023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76024       };
76025     } catch (std::exception& e) {
76026       {
76027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76028       };
76029     } catch (Dali::DaliException e) {
76030       {
76031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76032       };
76033     } catch (...) {
76034       {
76035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76036       };
76037     }
76038   }
76039
76040 }
76041
76042
76043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
76044   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76045   unsigned int arg2 ;
76046
76047   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76048   arg2 = (unsigned int)jarg2;
76049   {
76050     try {
76051       (arg1)->ScrollTo(arg2);
76052     } catch (std::out_of_range& e) {
76053       {
76054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76055       };
76056     } catch (std::exception& e) {
76057       {
76058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76059       };
76060     } catch (Dali::DaliException e) {
76061       {
76062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76063       };
76064     } catch (...) {
76065       {
76066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76067       };
76068     }
76069   }
76070
76071 }
76072
76073
76074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
76075   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76076   unsigned int arg2 ;
76077   float arg3 ;
76078
76079   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76080   arg2 = (unsigned int)jarg2;
76081   arg3 = (float)jarg3;
76082   {
76083     try {
76084       (arg1)->ScrollTo(arg2,arg3);
76085     } catch (std::out_of_range& e) {
76086       {
76087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76088       };
76089     } catch (std::exception& e) {
76090       {
76091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76092       };
76093     } catch (Dali::DaliException e) {
76094       {
76095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76096       };
76097     } catch (...) {
76098       {
76099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76100       };
76101     }
76102   }
76103
76104 }
76105
76106
76107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
76108   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76109   unsigned int arg2 ;
76110   float arg3 ;
76111   Dali::Toolkit::DirectionBias arg4 ;
76112
76113   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76114   arg2 = (unsigned int)jarg2;
76115   arg3 = (float)jarg3;
76116   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76117   {
76118     try {
76119       (arg1)->ScrollTo(arg2,arg3,arg4);
76120     } catch (std::out_of_range& e) {
76121       {
76122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76123       };
76124     } catch (std::exception& e) {
76125       {
76126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76127       };
76128     } catch (Dali::DaliException e) {
76129       {
76130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76131       };
76132     } catch (...) {
76133       {
76134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76135       };
76136     }
76137   }
76138
76139 }
76140
76141
76142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
76143   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76144   Dali::Actor *arg2 = 0 ;
76145
76146   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76147   arg2 = (Dali::Actor *)jarg2;
76148   if (!arg2) {
76149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76150     return ;
76151   }
76152   {
76153     try {
76154       (arg1)->ScrollTo(*arg2);
76155     } catch (std::out_of_range& e) {
76156       {
76157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76158       };
76159     } catch (std::exception& e) {
76160       {
76161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76162       };
76163     } catch (Dali::DaliException e) {
76164       {
76165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76166       };
76167     } catch (...) {
76168       {
76169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76170       };
76171     }
76172   }
76173
76174 }
76175
76176
76177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
76178   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76179   Dali::Actor *arg2 = 0 ;
76180   float arg3 ;
76181
76182   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76183   arg2 = (Dali::Actor *)jarg2;
76184   if (!arg2) {
76185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76186     return ;
76187   }
76188   arg3 = (float)jarg3;
76189   {
76190     try {
76191       (arg1)->ScrollTo(*arg2,arg3);
76192     } catch (std::out_of_range& e) {
76193       {
76194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76195       };
76196     } catch (std::exception& e) {
76197       {
76198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76199       };
76200     } catch (Dali::DaliException e) {
76201       {
76202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76203       };
76204     } catch (...) {
76205       {
76206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76207       };
76208     }
76209   }
76210
76211 }
76212
76213
76214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
76215   unsigned int jresult ;
76216   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76217   bool result;
76218
76219   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76220   {
76221     try {
76222       result = (bool)(arg1)->ScrollToSnapPoint();
76223     } catch (std::out_of_range& e) {
76224       {
76225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76226       };
76227     } catch (std::exception& e) {
76228       {
76229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76230       };
76231     } catch (Dali::DaliException e) {
76232       {
76233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76234       };
76235     } catch (...) {
76236       {
76237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76238       };
76239     }
76240   }
76241
76242   jresult = result;
76243   return jresult;
76244 }
76245
76246
76247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
76248   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76249   Dali::Constraint arg2 ;
76250   Dali::Constraint *argp2 ;
76251
76252   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76253   argp2 = (Dali::Constraint *)jarg2;
76254   if (!argp2) {
76255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
76256     return ;
76257   }
76258   arg2 = *argp2;
76259   {
76260     try {
76261       (arg1)->ApplyConstraintToChildren(arg2);
76262     } catch (std::out_of_range& e) {
76263       {
76264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76265       };
76266     } catch (std::exception& e) {
76267       {
76268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76269       };
76270     } catch (Dali::DaliException e) {
76271       {
76272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76273       };
76274     } catch (...) {
76275       {
76276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76277       };
76278     }
76279   }
76280
76281 }
76282
76283
76284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
76285   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76286
76287   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76288   {
76289     try {
76290       (arg1)->RemoveConstraintsFromChildren();
76291     } catch (std::out_of_range& e) {
76292       {
76293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76294       };
76295     } catch (std::exception& e) {
76296       {
76297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76298       };
76299     } catch (Dali::DaliException e) {
76300       {
76301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76302       };
76303     } catch (...) {
76304       {
76305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76306       };
76307     }
76308   }
76309
76310 }
76311
76312
76313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
76314   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76315   Dali::Toolkit::ScrollViewEffect arg2 ;
76316   Dali::Toolkit::ScrollViewEffect *argp2 ;
76317
76318   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76319   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76320   if (!argp2) {
76321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76322     return ;
76323   }
76324   arg2 = *argp2;
76325   {
76326     try {
76327       (arg1)->ApplyEffect(arg2);
76328     } catch (std::out_of_range& e) {
76329       {
76330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76331       };
76332     } catch (std::exception& e) {
76333       {
76334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76335       };
76336     } catch (Dali::DaliException e) {
76337       {
76338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76339       };
76340     } catch (...) {
76341       {
76342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76343       };
76344     }
76345   }
76346
76347 }
76348
76349
76350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
76351   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76352   Dali::Toolkit::ScrollViewEffect arg2 ;
76353   Dali::Toolkit::ScrollViewEffect *argp2 ;
76354
76355   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76356   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76357   if (!argp2) {
76358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76359     return ;
76360   }
76361   arg2 = *argp2;
76362   {
76363     try {
76364       (arg1)->RemoveEffect(arg2);
76365     } catch (std::out_of_range& e) {
76366       {
76367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76368       };
76369     } catch (std::exception& e) {
76370       {
76371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76372       };
76373     } catch (Dali::DaliException e) {
76374       {
76375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76376       };
76377     } catch (...) {
76378       {
76379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76380       };
76381     }
76382   }
76383
76384 }
76385
76386
76387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
76388   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76389
76390   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76391   {
76392     try {
76393       (arg1)->RemoveAllEffects();
76394     } catch (std::out_of_range& e) {
76395       {
76396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76397       };
76398     } catch (std::exception& e) {
76399       {
76400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76401       };
76402     } catch (Dali::DaliException e) {
76403       {
76404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76405       };
76406     } catch (...) {
76407       {
76408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76409       };
76410     }
76411   }
76412
76413 }
76414
76415
76416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
76417   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76418   Dali::Actor arg2 ;
76419   Dali::Actor *argp2 ;
76420
76421   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76422   argp2 = (Dali::Actor *)jarg2;
76423   if (!argp2) {
76424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76425     return ;
76426   }
76427   arg2 = *argp2;
76428   {
76429     try {
76430       (arg1)->BindActor(arg2);
76431     } catch (std::out_of_range& e) {
76432       {
76433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76434       };
76435     } catch (std::exception& e) {
76436       {
76437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76438       };
76439     } catch (Dali::DaliException e) {
76440       {
76441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76442       };
76443     } catch (...) {
76444       {
76445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76446       };
76447     }
76448   }
76449
76450 }
76451
76452
76453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
76454   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76455   Dali::Actor arg2 ;
76456   Dali::Actor *argp2 ;
76457
76458   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76459   argp2 = (Dali::Actor *)jarg2;
76460   if (!argp2) {
76461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76462     return ;
76463   }
76464   arg2 = *argp2;
76465   {
76466     try {
76467       (arg1)->UnbindActor(arg2);
76468     } catch (std::out_of_range& e) {
76469       {
76470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76471       };
76472     } catch (std::exception& e) {
76473       {
76474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76475       };
76476     } catch (Dali::DaliException e) {
76477       {
76478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76479       };
76480     } catch (...) {
76481       {
76482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76483       };
76484     }
76485   }
76486
76487 }
76488
76489
76490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
76491   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76492   Dali::Radian arg2 ;
76493   Dali::Radian arg3 ;
76494   Dali::Radian *argp2 ;
76495   Dali::Radian *argp3 ;
76496
76497   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76498   argp2 = (Dali::Radian *)jarg2;
76499   if (!argp2) {
76500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76501     return ;
76502   }
76503   arg2 = *argp2;
76504   argp3 = (Dali::Radian *)jarg3;
76505   if (!argp3) {
76506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76507     return ;
76508   }
76509   arg3 = *argp3;
76510   {
76511     try {
76512       (arg1)->SetScrollingDirection(arg2,arg3);
76513     } catch (std::out_of_range& e) {
76514       {
76515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76516       };
76517     } catch (std::exception& e) {
76518       {
76519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76520       };
76521     } catch (Dali::DaliException e) {
76522       {
76523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76524       };
76525     } catch (...) {
76526       {
76527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76528       };
76529     }
76530   }
76531
76532 }
76533
76534
76535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
76536   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76537   Dali::Radian arg2 ;
76538   Dali::Radian *argp2 ;
76539
76540   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76541   argp2 = (Dali::Radian *)jarg2;
76542   if (!argp2) {
76543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76544     return ;
76545   }
76546   arg2 = *argp2;
76547   {
76548     try {
76549       (arg1)->SetScrollingDirection(arg2);
76550     } catch (std::out_of_range& e) {
76551       {
76552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76553       };
76554     } catch (std::exception& e) {
76555       {
76556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76557       };
76558     } catch (Dali::DaliException e) {
76559       {
76560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76561       };
76562     } catch (...) {
76563       {
76564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76565       };
76566     }
76567   }
76568
76569 }
76570
76571
76572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76573   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76574   Dali::Radian arg2 ;
76575   Dali::Radian *argp2 ;
76576
76577   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76578   argp2 = (Dali::Radian *)jarg2;
76579   if (!argp2) {
76580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76581     return ;
76582   }
76583   arg2 = *argp2;
76584   {
76585     try {
76586       (arg1)->RemoveScrollingDirection(arg2);
76587     } catch (std::out_of_range& e) {
76588       {
76589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76590       };
76591     } catch (std::exception& e) {
76592       {
76593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76594       };
76595     } catch (Dali::DaliException e) {
76596       {
76597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76598       };
76599     } catch (...) {
76600       {
76601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76602       };
76603     }
76604   }
76605
76606 }
76607
76608
76609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76610   void * jresult ;
76611   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76612   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76613
76614   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76615   {
76616     try {
76617       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
76618     } catch (std::out_of_range& e) {
76619       {
76620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76621       };
76622     } catch (std::exception& e) {
76623       {
76624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76625       };
76626     } catch (Dali::DaliException e) {
76627       {
76628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76629       };
76630     } catch (...) {
76631       {
76632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76633       };
76634     }
76635   }
76636
76637   jresult = (void *)result;
76638   return jresult;
76639 }
76640
76641
76642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76643   int jresult ;
76644   int result;
76645
76646   result = (int)Dali::Toolkit::TableView::Property::ROWS;
76647   jresult = (int)result;
76648   return jresult;
76649 }
76650
76651
76652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
76653   int jresult ;
76654   int result;
76655
76656   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
76657   jresult = (int)result;
76658   return jresult;
76659 }
76660
76661
76662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
76663   int jresult ;
76664   int result;
76665
76666   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
76667   jresult = (int)result;
76668   return jresult;
76669 }
76670
76671
76672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
76673   int jresult ;
76674   int result;
76675
76676   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
76677   jresult = (int)result;
76678   return jresult;
76679 }
76680
76681
76682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
76683   int jresult ;
76684   int result;
76685
76686   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
76687   jresult = (int)result;
76688   return jresult;
76689 }
76690
76691
76692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
76693   void * jresult ;
76694   Dali::Toolkit::TableView::Property *result = 0 ;
76695
76696   {
76697     try {
76698       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
76699     } catch (std::out_of_range& e) {
76700       {
76701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76702       };
76703     } catch (std::exception& e) {
76704       {
76705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76706       };
76707     } catch (Dali::DaliException e) {
76708       {
76709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76710       };
76711     } catch (...) {
76712       {
76713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76714       };
76715     }
76716   }
76717
76718   jresult = (void *)result;
76719   return jresult;
76720 }
76721
76722
76723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
76724   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
76725
76726   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
76727   {
76728     try {
76729       delete arg1;
76730     } catch (std::out_of_range& e) {
76731       {
76732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76733       };
76734     } catch (std::exception& e) {
76735       {
76736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76737       };
76738     } catch (Dali::DaliException e) {
76739       {
76740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76741       };
76742     } catch (...) {
76743       {
76744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76745       };
76746     }
76747   }
76748
76749 }
76750
76751
76752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
76753   int jresult ;
76754   int result;
76755
76756   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
76757   jresult = (int)result;
76758   return jresult;
76759 }
76760
76761
76762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
76763   int jresult ;
76764   int result;
76765
76766   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
76767   jresult = (int)result;
76768   return jresult;
76769 }
76770
76771
76772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
76773   int jresult ;
76774   int result;
76775
76776   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
76777   jresult = (int)result;
76778   return jresult;
76779 }
76780
76781
76782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
76783   int jresult ;
76784   int result;
76785
76786   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
76787   jresult = (int)result;
76788   return jresult;
76789 }
76790
76791
76792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
76793   int jresult ;
76794   int result;
76795
76796   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
76797   jresult = (int)result;
76798   return jresult;
76799 }
76800
76801
76802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
76803   void * jresult ;
76804   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
76805
76806   {
76807     try {
76808       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
76809     } catch (std::out_of_range& e) {
76810       {
76811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76812       };
76813     } catch (std::exception& e) {
76814       {
76815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76816       };
76817     } catch (Dali::DaliException e) {
76818       {
76819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76820       };
76821     } catch (...) {
76822       {
76823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76824       };
76825     }
76826   }
76827
76828   jresult = (void *)result;
76829   return jresult;
76830 }
76831
76832
76833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
76834   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
76835
76836   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
76837   {
76838     try {
76839       delete arg1;
76840     } catch (std::out_of_range& e) {
76841       {
76842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76843       };
76844     } catch (std::exception& e) {
76845       {
76846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76847       };
76848     } catch (Dali::DaliException e) {
76849       {
76850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76851       };
76852     } catch (...) {
76853       {
76854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76855       };
76856     }
76857   }
76858
76859 }
76860
76861
76862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
76863   void * jresult ;
76864   unsigned int arg1 ;
76865   unsigned int arg2 ;
76866   unsigned int arg3 ;
76867   unsigned int arg4 ;
76868   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76869
76870   arg1 = (unsigned int)jarg1;
76871   arg2 = (unsigned int)jarg2;
76872   arg3 = (unsigned int)jarg3;
76873   arg4 = (unsigned int)jarg4;
76874   {
76875     try {
76876       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
76877     } catch (std::out_of_range& e) {
76878       {
76879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76880       };
76881     } catch (std::exception& e) {
76882       {
76883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76884       };
76885     } catch (Dali::DaliException e) {
76886       {
76887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76888       };
76889     } catch (...) {
76890       {
76891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76892       };
76893     }
76894   }
76895
76896   jresult = (void *)result;
76897   return jresult;
76898 }
76899
76900
76901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
76902   void * jresult ;
76903   unsigned int arg1 ;
76904   unsigned int arg2 ;
76905   unsigned int arg3 ;
76906   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76907
76908   arg1 = (unsigned int)jarg1;
76909   arg2 = (unsigned int)jarg2;
76910   arg3 = (unsigned int)jarg3;
76911   {
76912     try {
76913       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
76914     } catch (std::out_of_range& e) {
76915       {
76916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76917       };
76918     } catch (std::exception& e) {
76919       {
76920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76921       };
76922     } catch (Dali::DaliException e) {
76923       {
76924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76925       };
76926     } catch (...) {
76927       {
76928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76929       };
76930     }
76931   }
76932
76933   jresult = (void *)result;
76934   return jresult;
76935 }
76936
76937
76938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
76939   void * jresult ;
76940   unsigned int arg1 ;
76941   unsigned int arg2 ;
76942   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76943
76944   arg1 = (unsigned int)jarg1;
76945   arg2 = (unsigned int)jarg2;
76946   {
76947     try {
76948       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
76949     } catch (std::out_of_range& e) {
76950       {
76951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76952       };
76953     } catch (std::exception& e) {
76954       {
76955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76956       };
76957     } catch (Dali::DaliException e) {
76958       {
76959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76960       };
76961     } catch (...) {
76962       {
76963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76964       };
76965     }
76966   }
76967
76968   jresult = (void *)result;
76969   return jresult;
76970 }
76971
76972
76973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
76974   void * jresult ;
76975   unsigned int arg1 ;
76976   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76977
76978   arg1 = (unsigned int)jarg1;
76979   {
76980     try {
76981       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
76982     } catch (std::out_of_range& e) {
76983       {
76984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76985       };
76986     } catch (std::exception& e) {
76987       {
76988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76989       };
76990     } catch (Dali::DaliException e) {
76991       {
76992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76993       };
76994     } catch (...) {
76995       {
76996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76997       };
76998     }
76999   }
77000
77001   jresult = (void *)result;
77002   return jresult;
77003 }
77004
77005
77006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
77007   void * jresult ;
77008   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77009
77010   {
77011     try {
77012       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
77013     } catch (std::out_of_range& e) {
77014       {
77015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77016       };
77017     } catch (std::exception& e) {
77018       {
77019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77020       };
77021     } catch (Dali::DaliException e) {
77022       {
77023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77024       };
77025     } catch (...) {
77026       {
77027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77028       };
77029     }
77030   }
77031
77032   jresult = (void *)result;
77033   return jresult;
77034 }
77035
77036
77037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
77038   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77039   unsigned int arg2 ;
77040
77041   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77042   arg2 = (unsigned int)jarg2;
77043   if (arg1) (arg1)->rowIndex = arg2;
77044 }
77045
77046
77047 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
77048   unsigned int jresult ;
77049   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77050   unsigned int result;
77051
77052   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77053   result = (unsigned int) ((arg1)->rowIndex);
77054   jresult = result;
77055   return jresult;
77056 }
77057
77058
77059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
77060   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77061   unsigned int arg2 ;
77062
77063   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77064   arg2 = (unsigned int)jarg2;
77065   if (arg1) (arg1)->columnIndex = arg2;
77066 }
77067
77068
77069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
77070   unsigned int jresult ;
77071   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77072   unsigned int result;
77073
77074   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77075   result = (unsigned int) ((arg1)->columnIndex);
77076   jresult = result;
77077   return jresult;
77078 }
77079
77080
77081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
77082   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77083   unsigned int arg2 ;
77084
77085   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77086   arg2 = (unsigned int)jarg2;
77087   if (arg1) (arg1)->rowSpan = arg2;
77088 }
77089
77090
77091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
77092   unsigned int jresult ;
77093   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77094   unsigned int result;
77095
77096   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77097   result = (unsigned int) ((arg1)->rowSpan);
77098   jresult = result;
77099   return jresult;
77100 }
77101
77102
77103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
77104   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77105   unsigned int arg2 ;
77106
77107   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77108   arg2 = (unsigned int)jarg2;
77109   if (arg1) (arg1)->columnSpan = arg2;
77110 }
77111
77112
77113 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
77114   unsigned int jresult ;
77115   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77116   unsigned int result;
77117
77118   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77119   result = (unsigned int) ((arg1)->columnSpan);
77120   jresult = result;
77121   return jresult;
77122 }
77123
77124
77125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
77126   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77127
77128   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77129   {
77130     try {
77131       delete arg1;
77132     } catch (std::out_of_range& e) {
77133       {
77134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77135       };
77136     } catch (std::exception& e) {
77137       {
77138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77139       };
77140     } catch (Dali::DaliException e) {
77141       {
77142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77143       };
77144     } catch (...) {
77145       {
77146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77147       };
77148     }
77149   }
77150
77151 }
77152
77153
77154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
77155   void * jresult ;
77156   Dali::Toolkit::TableView *result = 0 ;
77157
77158   {
77159     try {
77160       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
77161     } catch (std::out_of_range& e) {
77162       {
77163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77164       };
77165     } catch (std::exception& e) {
77166       {
77167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77168       };
77169     } catch (Dali::DaliException e) {
77170       {
77171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77172       };
77173     } catch (...) {
77174       {
77175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77176       };
77177     }
77178   }
77179
77180   jresult = (void *)result;
77181   return jresult;
77182 }
77183
77184
77185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
77186   void * jresult ;
77187   Dali::Toolkit::TableView *arg1 = 0 ;
77188   Dali::Toolkit::TableView *result = 0 ;
77189
77190   arg1 = (Dali::Toolkit::TableView *)jarg1;
77191   if (!arg1) {
77192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77193     return 0;
77194   }
77195   {
77196     try {
77197       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
77198     } catch (std::out_of_range& e) {
77199       {
77200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77201       };
77202     } catch (std::exception& e) {
77203       {
77204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77205       };
77206     } catch (Dali::DaliException e) {
77207       {
77208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77209       };
77210     } catch (...) {
77211       {
77212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77213       };
77214     }
77215   }
77216
77217   jresult = (void *)result;
77218   return jresult;
77219 }
77220
77221
77222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
77223   void * jresult ;
77224   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77225   Dali::Toolkit::TableView *arg2 = 0 ;
77226   Dali::Toolkit::TableView *result = 0 ;
77227
77228   arg1 = (Dali::Toolkit::TableView *)jarg1;
77229   arg2 = (Dali::Toolkit::TableView *)jarg2;
77230   if (!arg2) {
77231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77232     return 0;
77233   }
77234   {
77235     try {
77236       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
77237     } catch (std::out_of_range& e) {
77238       {
77239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77240       };
77241     } catch (std::exception& e) {
77242       {
77243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77244       };
77245     } catch (Dali::DaliException e) {
77246       {
77247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77248       };
77249     } catch (...) {
77250       {
77251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77252       };
77253     }
77254   }
77255
77256   jresult = (void *)result;
77257   return jresult;
77258 }
77259
77260
77261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
77262   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77263
77264   arg1 = (Dali::Toolkit::TableView *)jarg1;
77265   {
77266     try {
77267       delete arg1;
77268     } catch (std::out_of_range& e) {
77269       {
77270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77271       };
77272     } catch (std::exception& e) {
77273       {
77274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77275       };
77276     } catch (Dali::DaliException e) {
77277       {
77278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77279       };
77280     } catch (...) {
77281       {
77282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77283       };
77284     }
77285   }
77286
77287 }
77288
77289
77290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
77291   void * jresult ;
77292   unsigned int arg1 ;
77293   unsigned int arg2 ;
77294   Dali::Toolkit::TableView result;
77295
77296   arg1 = (unsigned int)jarg1;
77297   arg2 = (unsigned int)jarg2;
77298   {
77299     try {
77300       result = Dali::Toolkit::TableView::New(arg1,arg2);
77301     } catch (std::out_of_range& e) {
77302       {
77303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77304       };
77305     } catch (std::exception& e) {
77306       {
77307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77308       };
77309     } catch (Dali::DaliException e) {
77310       {
77311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77312       };
77313     } catch (...) {
77314       {
77315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77316       };
77317     }
77318   }
77319
77320   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77321   return jresult;
77322 }
77323
77324
77325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
77326   void * jresult ;
77327   Dali::BaseHandle arg1 ;
77328   Dali::BaseHandle *argp1 ;
77329   Dali::Toolkit::TableView result;
77330
77331   argp1 = (Dali::BaseHandle *)jarg1;
77332   if (!argp1) {
77333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77334     return 0;
77335   }
77336   arg1 = *argp1;
77337   {
77338     try {
77339       result = Dali::Toolkit::TableView::DownCast(arg1);
77340     } catch (std::out_of_range& e) {
77341       {
77342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77343       };
77344     } catch (std::exception& e) {
77345       {
77346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77347       };
77348     } catch (Dali::DaliException e) {
77349       {
77350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77351       };
77352     } catch (...) {
77353       {
77354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77355       };
77356     }
77357   }
77358
77359   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77360   return jresult;
77361 }
77362
77363
77364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
77365   unsigned int jresult ;
77366   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77367   Dali::Actor arg2 ;
77368   Dali::Toolkit::TableView::CellPosition arg3 ;
77369   Dali::Actor *argp2 ;
77370   Dali::Toolkit::TableView::CellPosition *argp3 ;
77371   bool result;
77372
77373   arg1 = (Dali::Toolkit::TableView *)jarg1;
77374   argp2 = (Dali::Actor *)jarg2;
77375   if (!argp2) {
77376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77377     return 0;
77378   }
77379   arg2 = *argp2;
77380   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77381   if (!argp3) {
77382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77383     return 0;
77384   }
77385   arg3 = *argp3;
77386   {
77387     try {
77388       result = (bool)(arg1)->AddChild(arg2,arg3);
77389     } catch (std::out_of_range& e) {
77390       {
77391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77392       };
77393     } catch (std::exception& e) {
77394       {
77395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77396       };
77397     } catch (Dali::DaliException e) {
77398       {
77399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77400       };
77401     } catch (...) {
77402       {
77403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77404       };
77405     }
77406   }
77407
77408   jresult = result;
77409   return jresult;
77410 }
77411
77412
77413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
77414   void * jresult ;
77415   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77416   Dali::Toolkit::TableView::CellPosition arg2 ;
77417   Dali::Toolkit::TableView::CellPosition *argp2 ;
77418   Dali::Actor result;
77419
77420   arg1 = (Dali::Toolkit::TableView *)jarg1;
77421   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77422   if (!argp2) {
77423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77424     return 0;
77425   }
77426   arg2 = *argp2;
77427   {
77428     try {
77429       result = (arg1)->GetChildAt(arg2);
77430     } catch (std::out_of_range& e) {
77431       {
77432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77433       };
77434     } catch (std::exception& e) {
77435       {
77436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77437       };
77438     } catch (Dali::DaliException e) {
77439       {
77440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77441       };
77442     } catch (...) {
77443       {
77444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77445       };
77446     }
77447   }
77448
77449   jresult = new Dali::Actor((const Dali::Actor &)result);
77450   return jresult;
77451 }
77452
77453
77454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
77455   void * jresult ;
77456   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77457   Dali::Toolkit::TableView::CellPosition arg2 ;
77458   Dali::Toolkit::TableView::CellPosition *argp2 ;
77459   Dali::Actor result;
77460
77461   arg1 = (Dali::Toolkit::TableView *)jarg1;
77462   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77463   if (!argp2) {
77464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77465     return 0;
77466   }
77467   arg2 = *argp2;
77468   {
77469     try {
77470       result = (arg1)->RemoveChildAt(arg2);
77471     } catch (std::out_of_range& e) {
77472       {
77473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77474       };
77475     } catch (std::exception& e) {
77476       {
77477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77478       };
77479     } catch (Dali::DaliException e) {
77480       {
77481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77482       };
77483     } catch (...) {
77484       {
77485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77486       };
77487     }
77488   }
77489
77490   jresult = new Dali::Actor((const Dali::Actor &)result);
77491   return jresult;
77492 }
77493
77494
77495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
77496   unsigned int jresult ;
77497   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77498   Dali::Actor arg2 ;
77499   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
77500   Dali::Actor *argp2 ;
77501   bool result;
77502
77503   arg1 = (Dali::Toolkit::TableView *)jarg1;
77504   argp2 = (Dali::Actor *)jarg2;
77505   if (!argp2) {
77506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77507     return 0;
77508   }
77509   arg2 = *argp2;
77510   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77511   if (!arg3) {
77512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
77513     return 0;
77514   }
77515   {
77516     try {
77517       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
77518     } catch (std::out_of_range& e) {
77519       {
77520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77521       };
77522     } catch (std::exception& e) {
77523       {
77524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77525       };
77526     } catch (Dali::DaliException e) {
77527       {
77528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77529       };
77530     } catch (...) {
77531       {
77532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77533       };
77534     }
77535   }
77536
77537   jresult = result;
77538   return jresult;
77539 }
77540
77541
77542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
77543   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77544   unsigned int arg2 ;
77545
77546   arg1 = (Dali::Toolkit::TableView *)jarg1;
77547   arg2 = (unsigned int)jarg2;
77548   {
77549     try {
77550       (arg1)->InsertRow(arg2);
77551     } catch (std::out_of_range& e) {
77552       {
77553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77554       };
77555     } catch (std::exception& e) {
77556       {
77557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77558       };
77559     } catch (Dali::DaliException e) {
77560       {
77561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77562       };
77563     } catch (...) {
77564       {
77565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77566       };
77567     }
77568   }
77569
77570 }
77571
77572
77573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
77574   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77575   unsigned int arg2 ;
77576
77577   arg1 = (Dali::Toolkit::TableView *)jarg1;
77578   arg2 = (unsigned int)jarg2;
77579   {
77580     try {
77581       (arg1)->DeleteRow(arg2);
77582     } catch (std::out_of_range& e) {
77583       {
77584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77585       };
77586     } catch (std::exception& e) {
77587       {
77588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77589       };
77590     } catch (Dali::DaliException e) {
77591       {
77592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77593       };
77594     } catch (...) {
77595       {
77596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77597       };
77598     }
77599   }
77600
77601 }
77602
77603
77604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77605   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77606   unsigned int arg2 ;
77607   std::vector< Dali::Actor > *arg3 = 0 ;
77608
77609   arg1 = (Dali::Toolkit::TableView *)jarg1;
77610   arg2 = (unsigned int)jarg2;
77611   arg3 = (std::vector< Dali::Actor > *)jarg3;
77612   if (!arg3) {
77613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77614     return ;
77615   }
77616   {
77617     try {
77618       (arg1)->DeleteRow(arg2,*arg3);
77619     } catch (std::out_of_range& e) {
77620       {
77621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77622       };
77623     } catch (std::exception& e) {
77624       {
77625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77626       };
77627     } catch (Dali::DaliException e) {
77628       {
77629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77630       };
77631     } catch (...) {
77632       {
77633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77634       };
77635     }
77636   }
77637
77638 }
77639
77640
77641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
77642   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77643   unsigned int arg2 ;
77644
77645   arg1 = (Dali::Toolkit::TableView *)jarg1;
77646   arg2 = (unsigned int)jarg2;
77647   {
77648     try {
77649       (arg1)->InsertColumn(arg2);
77650     } catch (std::out_of_range& e) {
77651       {
77652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77653       };
77654     } catch (std::exception& e) {
77655       {
77656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77657       };
77658     } catch (Dali::DaliException e) {
77659       {
77660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77661       };
77662     } catch (...) {
77663       {
77664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77665       };
77666     }
77667   }
77668
77669 }
77670
77671
77672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
77673   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77674   unsigned int arg2 ;
77675
77676   arg1 = (Dali::Toolkit::TableView *)jarg1;
77677   arg2 = (unsigned int)jarg2;
77678   {
77679     try {
77680       (arg1)->DeleteColumn(arg2);
77681     } catch (std::out_of_range& e) {
77682       {
77683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77684       };
77685     } catch (std::exception& e) {
77686       {
77687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77688       };
77689     } catch (Dali::DaliException e) {
77690       {
77691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77692       };
77693     } catch (...) {
77694       {
77695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77696       };
77697     }
77698   }
77699
77700 }
77701
77702
77703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77704   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77705   unsigned int arg2 ;
77706   std::vector< Dali::Actor > *arg3 = 0 ;
77707
77708   arg1 = (Dali::Toolkit::TableView *)jarg1;
77709   arg2 = (unsigned int)jarg2;
77710   arg3 = (std::vector< Dali::Actor > *)jarg3;
77711   if (!arg3) {
77712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77713     return ;
77714   }
77715   {
77716     try {
77717       (arg1)->DeleteColumn(arg2,*arg3);
77718     } catch (std::out_of_range& e) {
77719       {
77720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77721       };
77722     } catch (std::exception& e) {
77723       {
77724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77725       };
77726     } catch (Dali::DaliException e) {
77727       {
77728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77729       };
77730     } catch (...) {
77731       {
77732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77733       };
77734     }
77735   }
77736
77737 }
77738
77739
77740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
77741   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77742   unsigned int arg2 ;
77743   unsigned int arg3 ;
77744
77745   arg1 = (Dali::Toolkit::TableView *)jarg1;
77746   arg2 = (unsigned int)jarg2;
77747   arg3 = (unsigned int)jarg3;
77748   {
77749     try {
77750       (arg1)->Resize(arg2,arg3);
77751     } catch (std::out_of_range& e) {
77752       {
77753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77754       };
77755     } catch (std::exception& e) {
77756       {
77757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77758       };
77759     } catch (Dali::DaliException e) {
77760       {
77761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77762       };
77763     } catch (...) {
77764       {
77765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77766       };
77767     }
77768   }
77769
77770 }
77771
77772
77773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
77774   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77775   unsigned int arg2 ;
77776   unsigned int arg3 ;
77777   std::vector< Dali::Actor > *arg4 = 0 ;
77778
77779   arg1 = (Dali::Toolkit::TableView *)jarg1;
77780   arg2 = (unsigned int)jarg2;
77781   arg3 = (unsigned int)jarg3;
77782   arg4 = (std::vector< Dali::Actor > *)jarg4;
77783   if (!arg4) {
77784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77785     return ;
77786   }
77787   {
77788     try {
77789       (arg1)->Resize(arg2,arg3,*arg4);
77790     } catch (std::out_of_range& e) {
77791       {
77792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77793       };
77794     } catch (std::exception& e) {
77795       {
77796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77797       };
77798     } catch (Dali::DaliException e) {
77799       {
77800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77801       };
77802     } catch (...) {
77803       {
77804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77805       };
77806     }
77807   }
77808
77809 }
77810
77811
77812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
77813   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77814   Dali::Size arg2 ;
77815   Dali::Size *argp2 ;
77816
77817   arg1 = (Dali::Toolkit::TableView *)jarg1;
77818   argp2 = (Dali::Size *)jarg2;
77819   if (!argp2) {
77820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
77821     return ;
77822   }
77823   arg2 = *argp2;
77824   {
77825     try {
77826       (arg1)->SetCellPadding(arg2);
77827     } catch (std::out_of_range& e) {
77828       {
77829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77830       };
77831     } catch (std::exception& e) {
77832       {
77833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77834       };
77835     } catch (Dali::DaliException e) {
77836       {
77837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77838       };
77839     } catch (...) {
77840       {
77841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77842       };
77843     }
77844   }
77845
77846 }
77847
77848
77849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
77850   void * jresult ;
77851   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77852   Dali::Size result;
77853
77854   arg1 = (Dali::Toolkit::TableView *)jarg1;
77855   {
77856     try {
77857       result = (arg1)->GetCellPadding();
77858     } catch (std::out_of_range& e) {
77859       {
77860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77861       };
77862     } catch (std::exception& e) {
77863       {
77864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77865       };
77866     } catch (Dali::DaliException e) {
77867       {
77868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77869       };
77870     } catch (...) {
77871       {
77872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77873       };
77874     }
77875   }
77876
77877   jresult = new Dali::Size((const Dali::Size &)result);
77878   return jresult;
77879 }
77880
77881
77882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
77883   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77884   unsigned int arg2 ;
77885
77886   arg1 = (Dali::Toolkit::TableView *)jarg1;
77887   arg2 = (unsigned int)jarg2;
77888   {
77889     try {
77890       (arg1)->SetFitHeight(arg2);
77891     } catch (std::out_of_range& e) {
77892       {
77893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77894       };
77895     } catch (std::exception& e) {
77896       {
77897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77898       };
77899     } catch (Dali::DaliException e) {
77900       {
77901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77902       };
77903     } catch (...) {
77904       {
77905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77906       };
77907     }
77908   }
77909
77910 }
77911
77912
77913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
77914   unsigned int jresult ;
77915   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77916   unsigned int arg2 ;
77917   bool result;
77918
77919   arg1 = (Dali::Toolkit::TableView *)jarg1;
77920   arg2 = (unsigned int)jarg2;
77921   {
77922     try {
77923       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
77924     } catch (std::out_of_range& e) {
77925       {
77926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77927       };
77928     } catch (std::exception& e) {
77929       {
77930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77931       };
77932     } catch (Dali::DaliException e) {
77933       {
77934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77935       };
77936     } catch (...) {
77937       {
77938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77939       };
77940     }
77941   }
77942
77943   jresult = result;
77944   return jresult;
77945 }
77946
77947
77948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
77949   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77950   unsigned int arg2 ;
77951
77952   arg1 = (Dali::Toolkit::TableView *)jarg1;
77953   arg2 = (unsigned int)jarg2;
77954   {
77955     try {
77956       (arg1)->SetFitWidth(arg2);
77957     } catch (std::out_of_range& e) {
77958       {
77959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77960       };
77961     } catch (std::exception& e) {
77962       {
77963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77964       };
77965     } catch (Dali::DaliException e) {
77966       {
77967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77968       };
77969     } catch (...) {
77970       {
77971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77972       };
77973     }
77974   }
77975
77976 }
77977
77978
77979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
77980   unsigned int jresult ;
77981   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77982   unsigned int arg2 ;
77983   bool result;
77984
77985   arg1 = (Dali::Toolkit::TableView *)jarg1;
77986   arg2 = (unsigned int)jarg2;
77987   {
77988     try {
77989       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
77990     } catch (std::out_of_range& e) {
77991       {
77992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77993       };
77994     } catch (std::exception& e) {
77995       {
77996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77997       };
77998     } catch (Dali::DaliException e) {
77999       {
78000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78001       };
78002     } catch (...) {
78003       {
78004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78005       };
78006     }
78007   }
78008
78009   jresult = result;
78010   return jresult;
78011 }
78012
78013
78014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78015   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78016   unsigned int arg2 ;
78017   float arg3 ;
78018
78019   arg1 = (Dali::Toolkit::TableView *)jarg1;
78020   arg2 = (unsigned int)jarg2;
78021   arg3 = (float)jarg3;
78022   {
78023     try {
78024       (arg1)->SetFixedHeight(arg2,arg3);
78025     } catch (std::out_of_range& e) {
78026       {
78027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78028       };
78029     } catch (std::exception& e) {
78030       {
78031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78032       };
78033     } catch (Dali::DaliException e) {
78034       {
78035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78036       };
78037     } catch (...) {
78038       {
78039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78040       };
78041     }
78042   }
78043
78044 }
78045
78046
78047 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
78048   float jresult ;
78049   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78050   unsigned int arg2 ;
78051   float result;
78052
78053   arg1 = (Dali::Toolkit::TableView *)jarg1;
78054   arg2 = (unsigned int)jarg2;
78055   {
78056     try {
78057       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
78058     } catch (std::out_of_range& e) {
78059       {
78060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78061       };
78062     } catch (std::exception& e) {
78063       {
78064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78065       };
78066     } catch (Dali::DaliException e) {
78067       {
78068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78069       };
78070     } catch (...) {
78071       {
78072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78073       };
78074     }
78075   }
78076
78077   jresult = result;
78078   return jresult;
78079 }
78080
78081
78082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78083   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78084   unsigned int arg2 ;
78085   float arg3 ;
78086
78087   arg1 = (Dali::Toolkit::TableView *)jarg1;
78088   arg2 = (unsigned int)jarg2;
78089   arg3 = (float)jarg3;
78090   {
78091     try {
78092       (arg1)->SetRelativeHeight(arg2,arg3);
78093     } catch (std::out_of_range& e) {
78094       {
78095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78096       };
78097     } catch (std::exception& e) {
78098       {
78099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78100       };
78101     } catch (Dali::DaliException e) {
78102       {
78103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78104       };
78105     } catch (...) {
78106       {
78107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78108       };
78109     }
78110   }
78111
78112 }
78113
78114
78115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
78116   float jresult ;
78117   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78118   unsigned int arg2 ;
78119   float result;
78120
78121   arg1 = (Dali::Toolkit::TableView *)jarg1;
78122   arg2 = (unsigned int)jarg2;
78123   {
78124     try {
78125       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
78126     } catch (std::out_of_range& e) {
78127       {
78128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78129       };
78130     } catch (std::exception& e) {
78131       {
78132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78133       };
78134     } catch (Dali::DaliException e) {
78135       {
78136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78137       };
78138     } catch (...) {
78139       {
78140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78141       };
78142     }
78143   }
78144
78145   jresult = result;
78146   return jresult;
78147 }
78148
78149
78150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78151   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78152   unsigned int arg2 ;
78153   float arg3 ;
78154
78155   arg1 = (Dali::Toolkit::TableView *)jarg1;
78156   arg2 = (unsigned int)jarg2;
78157   arg3 = (float)jarg3;
78158   {
78159     try {
78160       (arg1)->SetFixedWidth(arg2,arg3);
78161     } catch (std::out_of_range& e) {
78162       {
78163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78164       };
78165     } catch (std::exception& e) {
78166       {
78167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78168       };
78169     } catch (Dali::DaliException e) {
78170       {
78171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78172       };
78173     } catch (...) {
78174       {
78175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78176       };
78177     }
78178   }
78179
78180 }
78181
78182
78183 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
78184   float jresult ;
78185   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78186   unsigned int arg2 ;
78187   float result;
78188
78189   arg1 = (Dali::Toolkit::TableView *)jarg1;
78190   arg2 = (unsigned int)jarg2;
78191   {
78192     try {
78193       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
78194     } catch (std::out_of_range& e) {
78195       {
78196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78197       };
78198     } catch (std::exception& e) {
78199       {
78200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78201       };
78202     } catch (Dali::DaliException e) {
78203       {
78204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78205       };
78206     } catch (...) {
78207       {
78208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78209       };
78210     }
78211   }
78212
78213   jresult = result;
78214   return jresult;
78215 }
78216
78217
78218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78219   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78220   unsigned int arg2 ;
78221   float arg3 ;
78222
78223   arg1 = (Dali::Toolkit::TableView *)jarg1;
78224   arg2 = (unsigned int)jarg2;
78225   arg3 = (float)jarg3;
78226   {
78227     try {
78228       (arg1)->SetRelativeWidth(arg2,arg3);
78229     } catch (std::out_of_range& e) {
78230       {
78231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78232       };
78233     } catch (std::exception& e) {
78234       {
78235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78236       };
78237     } catch (Dali::DaliException e) {
78238       {
78239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78240       };
78241     } catch (...) {
78242       {
78243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78244       };
78245     }
78246   }
78247
78248 }
78249
78250
78251 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
78252   float jresult ;
78253   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78254   unsigned int arg2 ;
78255   float result;
78256
78257   arg1 = (Dali::Toolkit::TableView *)jarg1;
78258   arg2 = (unsigned int)jarg2;
78259   {
78260     try {
78261       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
78262     } catch (std::out_of_range& e) {
78263       {
78264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78265       };
78266     } catch (std::exception& e) {
78267       {
78268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78269       };
78270     } catch (Dali::DaliException e) {
78271       {
78272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78273       };
78274     } catch (...) {
78275       {
78276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78277       };
78278     }
78279   }
78280
78281   jresult = result;
78282   return jresult;
78283 }
78284
78285
78286 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
78287   unsigned int jresult ;
78288   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78289   unsigned int result;
78290
78291   arg1 = (Dali::Toolkit::TableView *)jarg1;
78292   {
78293     try {
78294       result = (unsigned int)(arg1)->GetRows();
78295     } catch (std::out_of_range& e) {
78296       {
78297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78298       };
78299     } catch (std::exception& e) {
78300       {
78301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78302       };
78303     } catch (Dali::DaliException e) {
78304       {
78305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78306       };
78307     } catch (...) {
78308       {
78309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78310       };
78311     }
78312   }
78313
78314   jresult = result;
78315   return jresult;
78316 }
78317
78318
78319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
78320   unsigned int jresult ;
78321   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78322   unsigned int result;
78323
78324   arg1 = (Dali::Toolkit::TableView *)jarg1;
78325   {
78326     try {
78327       result = (unsigned int)(arg1)->GetColumns();
78328     } catch (std::out_of_range& e) {
78329       {
78330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78331       };
78332     } catch (std::exception& e) {
78333       {
78334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78335       };
78336     } catch (Dali::DaliException e) {
78337       {
78338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78339       };
78340     } catch (...) {
78341       {
78342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78343       };
78344     }
78345   }
78346
78347   jresult = result;
78348   return jresult;
78349 }
78350
78351
78352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
78353   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78354   Dali::Toolkit::TableView::CellPosition arg2 ;
78355   Dali::HorizontalAlignment::Type arg3 ;
78356   Dali::VerticalAlignment::Type arg4 ;
78357   Dali::Toolkit::TableView::CellPosition *argp2 ;
78358
78359   arg1 = (Dali::Toolkit::TableView *)jarg1;
78360   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
78361   if (!argp2) {
78362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
78363     return ;
78364   }
78365   arg2 = *argp2;
78366   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
78367   arg4 = (Dali::VerticalAlignment::Type)jarg4;
78368   {
78369     try {
78370       (arg1)->SetCellAlignment(arg2,arg3,arg4);
78371     } catch (std::out_of_range& e) {
78372       {
78373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78374       };
78375     } catch (std::exception& e) {
78376       {
78377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78378       };
78379     } catch (Dali::DaliException e) {
78380       {
78381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78382       };
78383     } catch (...) {
78384       {
78385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78386       };
78387     }
78388   }
78389
78390 }
78391
78392
78393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
78394   unsigned int jresult ;
78395   unsigned int result;
78396
78397   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
78398   jresult = result;
78399   return jresult;
78400 }
78401
78402
78403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78404   int jresult ;
78405   int result;
78406
78407   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78408   jresult = (int)result;
78409   return jresult;
78410 }
78411
78412
78413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78414   int jresult ;
78415   int result;
78416
78417   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78418   jresult = (int)result;
78419   return jresult;
78420 }
78421
78422
78423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78424   int jresult ;
78425   int result;
78426
78427   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78428   jresult = (int)result;
78429   return jresult;
78430 }
78431
78432
78433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78434   int jresult ;
78435   int result;
78436
78437   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78438   jresult = (int)result;
78439   return jresult;
78440 }
78441
78442
78443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78444   int jresult ;
78445   int result;
78446
78447   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78448   jresult = (int)result;
78449   return jresult;
78450 }
78451
78452
78453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78454   int jresult ;
78455   int result;
78456
78457   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78458   jresult = (int)result;
78459   return jresult;
78460 }
78461
78462
78463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78464   int jresult ;
78465   int result;
78466
78467   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78468   jresult = (int)result;
78469   return jresult;
78470 }
78471
78472
78473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78474   int jresult ;
78475   int result;
78476
78477   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78478   jresult = (int)result;
78479   return jresult;
78480 }
78481
78482
78483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78484   int jresult ;
78485   int result;
78486
78487   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78488   jresult = (int)result;
78489   return jresult;
78490 }
78491
78492
78493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78494   int jresult ;
78495   int result;
78496
78497   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78498   jresult = (int)result;
78499   return jresult;
78500 }
78501
78502
78503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78504   int jresult ;
78505   int result;
78506
78507   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78508   jresult = (int)result;
78509   return jresult;
78510 }
78511
78512
78513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78514   int jresult ;
78515   int result;
78516
78517   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78518   jresult = (int)result;
78519   return jresult;
78520 }
78521
78522
78523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78524   int jresult ;
78525   int result;
78526
78527   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78528   jresult = (int)result;
78529   return jresult;
78530 }
78531
78532
78533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78534   int jresult ;
78535   int result;
78536
78537   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78538   jresult = (int)result;
78539   return jresult;
78540 }
78541
78542
78543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78544   int jresult ;
78545   int result;
78546
78547   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78548   jresult = (int)result;
78549   return jresult;
78550 }
78551
78552
78553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78554   int jresult ;
78555   int result;
78556
78557   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78558   jresult = (int)result;
78559   return jresult;
78560 }
78561
78562
78563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78564   int jresult ;
78565   int result;
78566
78567   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78568   jresult = (int)result;
78569   return jresult;
78570 }
78571
78572
78573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78574   int jresult ;
78575   int result;
78576
78577   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78578   jresult = (int)result;
78579   return jresult;
78580 }
78581
78582
78583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78584   void * jresult ;
78585   Dali::Toolkit::TextLabel::Property *result = 0 ;
78586
78587   {
78588     try {
78589       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78590     } catch (std::out_of_range& e) {
78591       {
78592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78593       };
78594     } catch (std::exception& e) {
78595       {
78596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78597       };
78598     } catch (Dali::DaliException e) {
78599       {
78600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78601       };
78602     } catch (...) {
78603       {
78604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78605       };
78606     }
78607   }
78608
78609   jresult = (void *)result;
78610   return jresult;
78611 }
78612
78613
78614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78615   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78616
78617   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78618   {
78619     try {
78620       delete arg1;
78621     } catch (std::out_of_range& e) {
78622       {
78623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78624       };
78625     } catch (std::exception& e) {
78626       {
78627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78628       };
78629     } catch (Dali::DaliException e) {
78630       {
78631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78632       };
78633     } catch (...) {
78634       {
78635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78636       };
78637     }
78638   }
78639
78640 }
78641
78642
78643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78644   void * jresult ;
78645   Dali::Toolkit::TextLabel result;
78646
78647   {
78648     try {
78649       result = Dali::Toolkit::TextLabel::New();
78650     } catch (std::out_of_range& e) {
78651       {
78652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78653       };
78654     } catch (std::exception& e) {
78655       {
78656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78657       };
78658     } catch (Dali::DaliException e) {
78659       {
78660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78661       };
78662     } catch (...) {
78663       {
78664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78665       };
78666     }
78667   }
78668
78669   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78670   return jresult;
78671 }
78672
78673
78674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78675   void * jresult ;
78676   std::string *arg1 = 0 ;
78677   Dali::Toolkit::TextLabel result;
78678
78679   if (!jarg1) {
78680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78681     return 0;
78682   }
78683   std::string arg1_str(jarg1);
78684   arg1 = &arg1_str;
78685   {
78686     try {
78687       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
78688     } catch (std::out_of_range& e) {
78689       {
78690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78691       };
78692     } catch (std::exception& e) {
78693       {
78694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78695       };
78696     } catch (Dali::DaliException e) {
78697       {
78698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78699       };
78700     } catch (...) {
78701       {
78702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78703       };
78704     }
78705   }
78706
78707   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78708
78709   //argout typemap for const std::string&
78710
78711   return jresult;
78712 }
78713
78714
78715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78716   void * jresult ;
78717   Dali::Toolkit::TextLabel *result = 0 ;
78718
78719   {
78720     try {
78721       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78722     } catch (std::out_of_range& e) {
78723       {
78724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78725       };
78726     } catch (std::exception& e) {
78727       {
78728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78729       };
78730     } catch (Dali::DaliException e) {
78731       {
78732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78733       };
78734     } catch (...) {
78735       {
78736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78737       };
78738     }
78739   }
78740
78741   jresult = (void *)result;
78742   return jresult;
78743 }
78744
78745
78746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78747   void * jresult ;
78748   Dali::Toolkit::TextLabel *arg1 = 0 ;
78749   Dali::Toolkit::TextLabel *result = 0 ;
78750
78751   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78752   if (!arg1) {
78753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78754     return 0;
78755   }
78756   {
78757     try {
78758       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78759     } catch (std::out_of_range& e) {
78760       {
78761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78762       };
78763     } catch (std::exception& e) {
78764       {
78765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78766       };
78767     } catch (Dali::DaliException e) {
78768       {
78769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78770       };
78771     } catch (...) {
78772       {
78773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78774       };
78775     }
78776   }
78777
78778   jresult = (void *)result;
78779   return jresult;
78780 }
78781
78782
78783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78784   void * jresult ;
78785   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78786   Dali::Toolkit::TextLabel *arg2 = 0 ;
78787   Dali::Toolkit::TextLabel *result = 0 ;
78788
78789   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78790   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78791   if (!arg2) {
78792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78793     return 0;
78794   }
78795   {
78796     try {
78797       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
78798     } catch (std::out_of_range& e) {
78799       {
78800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78801       };
78802     } catch (std::exception& e) {
78803       {
78804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78805       };
78806     } catch (Dali::DaliException e) {
78807       {
78808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78809       };
78810     } catch (...) {
78811       {
78812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78813       };
78814     }
78815   }
78816
78817   jresult = (void *)result;
78818   return jresult;
78819 }
78820
78821
78822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
78823   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78824
78825   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78826   {
78827     try {
78828       delete arg1;
78829     } catch (std::out_of_range& e) {
78830       {
78831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78832       };
78833     } catch (std::exception& e) {
78834       {
78835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78836       };
78837     } catch (Dali::DaliException e) {
78838       {
78839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78840       };
78841     } catch (...) {
78842       {
78843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78844       };
78845     }
78846   }
78847
78848 }
78849
78850
78851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
78852   void * jresult ;
78853   Dali::BaseHandle arg1 ;
78854   Dali::BaseHandle *argp1 ;
78855   Dali::Toolkit::TextLabel result;
78856
78857   argp1 = (Dali::BaseHandle *)jarg1;
78858   if (!argp1) {
78859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78860     return 0;
78861   }
78862   arg1 = *argp1;
78863   {
78864     try {
78865       result = Dali::Toolkit::TextLabel::DownCast(arg1);
78866     } catch (std::out_of_range& e) {
78867       {
78868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78869       };
78870     } catch (std::exception& e) {
78871       {
78872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78873       };
78874     } catch (Dali::DaliException e) {
78875       {
78876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78877       };
78878     } catch (...) {
78879       {
78880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78881       };
78882     }
78883   }
78884
78885   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78886   return jresult;
78887 }
78888
78889
78890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
78891   void * jresult ;
78892   Dali::Toolkit::AccessibilityManager *result = 0 ;
78893
78894   {
78895     try {
78896       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
78897     } catch (std::out_of_range& e) {
78898       {
78899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78900       };
78901     } catch (std::exception& e) {
78902       {
78903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78904       };
78905     } catch (Dali::DaliException e) {
78906       {
78907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78908       };
78909     } catch (...) {
78910       {
78911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78912       };
78913     }
78914   }
78915
78916   jresult = (void *)result;
78917   return jresult;
78918 }
78919
78920
78921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
78922   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78923
78924   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78925   {
78926     try {
78927       delete arg1;
78928     } catch (std::out_of_range& e) {
78929       {
78930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78931       };
78932     } catch (std::exception& e) {
78933       {
78934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78935       };
78936     } catch (Dali::DaliException e) {
78937       {
78938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78939       };
78940     } catch (...) {
78941       {
78942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78943       };
78944     }
78945   }
78946
78947 }
78948
78949
78950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
78951   void * jresult ;
78952   Dali::Toolkit::AccessibilityManager result;
78953
78954   {
78955     try {
78956       result = Dali::Toolkit::AccessibilityManager::Get();
78957     } catch (std::out_of_range& e) {
78958       {
78959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78960       };
78961     } catch (std::exception& e) {
78962       {
78963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78964       };
78965     } catch (Dali::DaliException e) {
78966       {
78967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78968       };
78969     } catch (...) {
78970       {
78971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78972       };
78973     }
78974   }
78975
78976   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
78977   return jresult;
78978 }
78979
78980
78981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
78982   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78983   Dali::Actor arg2 ;
78984   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78985   std::string *arg4 = 0 ;
78986   Dali::Actor *argp2 ;
78987
78988   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78989   argp2 = (Dali::Actor *)jarg2;
78990   if (!argp2) {
78991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78992     return ;
78993   }
78994   arg2 = *argp2;
78995   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78996   if (!jarg4) {
78997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78998     return ;
78999   }
79000   std::string arg4_str(jarg4);
79001   arg4 = &arg4_str;
79002   {
79003     try {
79004       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79005     } catch (std::out_of_range& e) {
79006       {
79007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79008       };
79009     } catch (std::exception& e) {
79010       {
79011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79012       };
79013     } catch (Dali::DaliException e) {
79014       {
79015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79016       };
79017     } catch (...) {
79018       {
79019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79020       };
79021     }
79022   }
79023
79024
79025   //argout typemap for const std::string&
79026
79027 }
79028
79029
79030 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79031   char * jresult ;
79032   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79033   Dali::Actor arg2 ;
79034   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79035   Dali::Actor *argp2 ;
79036   std::string result;
79037
79038   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79039   argp2 = (Dali::Actor *)jarg2;
79040   if (!argp2) {
79041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79042     return 0;
79043   }
79044   arg2 = *argp2;
79045   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79046   {
79047     try {
79048       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79049     } catch (std::out_of_range& e) {
79050       {
79051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79052       };
79053     } catch (std::exception& e) {
79054       {
79055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79056       };
79057     } catch (Dali::DaliException e) {
79058       {
79059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79060       };
79061     } catch (...) {
79062       {
79063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79064       };
79065     }
79066   }
79067
79068   jresult = SWIG_csharp_string_callback((&result)->c_str());
79069   return jresult;
79070 }
79071
79072
79073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79074   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79075   Dali::Actor arg2 ;
79076   unsigned int arg3 ;
79077   Dali::Actor *argp2 ;
79078
79079   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79080   argp2 = (Dali::Actor *)jarg2;
79081   if (!argp2) {
79082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79083     return ;
79084   }
79085   arg2 = *argp2;
79086   arg3 = (unsigned int)jarg3;
79087   {
79088     try {
79089       (arg1)->SetFocusOrder(arg2,arg3);
79090     } catch (std::out_of_range& e) {
79091       {
79092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79093       };
79094     } catch (std::exception& e) {
79095       {
79096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79097       };
79098     } catch (Dali::DaliException e) {
79099       {
79100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79101       };
79102     } catch (...) {
79103       {
79104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79105       };
79106     }
79107   }
79108
79109 }
79110
79111
79112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79113   unsigned int jresult ;
79114   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79115   Dali::Actor arg2 ;
79116   Dali::Actor *argp2 ;
79117   unsigned int result;
79118
79119   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79120   argp2 = (Dali::Actor *)jarg2;
79121   if (!argp2) {
79122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79123     return 0;
79124   }
79125   arg2 = *argp2;
79126   {
79127     try {
79128       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79129     } catch (std::out_of_range& e) {
79130       {
79131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79132       };
79133     } catch (std::exception& e) {
79134       {
79135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79136       };
79137     } catch (Dali::DaliException e) {
79138       {
79139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79140       };
79141     } catch (...) {
79142       {
79143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79144       };
79145     }
79146   }
79147
79148   jresult = result;
79149   return jresult;
79150 }
79151
79152
79153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79154   unsigned int jresult ;
79155   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79156   unsigned int result;
79157
79158   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79159   {
79160     try {
79161       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79162     } catch (std::out_of_range& e) {
79163       {
79164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79165       };
79166     } catch (std::exception& e) {
79167       {
79168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79169       };
79170     } catch (Dali::DaliException e) {
79171       {
79172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79173       };
79174     } catch (...) {
79175       {
79176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79177       };
79178     }
79179   }
79180
79181   jresult = result;
79182   return jresult;
79183 }
79184
79185
79186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79187   void * jresult ;
79188   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79189   unsigned int arg2 ;
79190   Dali::Actor result;
79191
79192   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79193   arg2 = (unsigned int)jarg2;
79194   {
79195     try {
79196       result = (arg1)->GetActorByFocusOrder(arg2);
79197     } catch (std::out_of_range& e) {
79198       {
79199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79200       };
79201     } catch (std::exception& e) {
79202       {
79203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79204       };
79205     } catch (Dali::DaliException e) {
79206       {
79207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79208       };
79209     } catch (...) {
79210       {
79211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79212       };
79213     }
79214   }
79215
79216   jresult = new Dali::Actor((const Dali::Actor &)result);
79217   return jresult;
79218 }
79219
79220
79221 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79222   unsigned int jresult ;
79223   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79224   Dali::Actor arg2 ;
79225   Dali::Actor *argp2 ;
79226   bool result;
79227
79228   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79229   argp2 = (Dali::Actor *)jarg2;
79230   if (!argp2) {
79231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79232     return 0;
79233   }
79234   arg2 = *argp2;
79235   {
79236     try {
79237       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79238     } catch (std::out_of_range& e) {
79239       {
79240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79241       };
79242     } catch (std::exception& e) {
79243       {
79244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79245       };
79246     } catch (Dali::DaliException e) {
79247       {
79248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79249       };
79250     } catch (...) {
79251       {
79252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79253       };
79254     }
79255   }
79256
79257   jresult = result;
79258   return jresult;
79259 }
79260
79261
79262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79263   void * jresult ;
79264   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79265   Dali::Actor result;
79266
79267   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79268   {
79269     try {
79270       result = (arg1)->GetCurrentFocusActor();
79271     } catch (std::out_of_range& e) {
79272       {
79273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79274       };
79275     } catch (std::exception& e) {
79276       {
79277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79278       };
79279     } catch (Dali::DaliException e) {
79280       {
79281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79282       };
79283     } catch (...) {
79284       {
79285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79286       };
79287     }
79288   }
79289
79290   jresult = new Dali::Actor((const Dali::Actor &)result);
79291   return jresult;
79292 }
79293
79294
79295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79296   void * jresult ;
79297   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79298   Dali::Actor result;
79299
79300   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79301   {
79302     try {
79303       result = (arg1)->GetCurrentFocusGroup();
79304     } catch (std::out_of_range& e) {
79305       {
79306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79307       };
79308     } catch (std::exception& e) {
79309       {
79310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79311       };
79312     } catch (Dali::DaliException e) {
79313       {
79314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79315       };
79316     } catch (...) {
79317       {
79318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79319       };
79320     }
79321   }
79322
79323   jresult = new Dali::Actor((const Dali::Actor &)result);
79324   return jresult;
79325 }
79326
79327
79328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79329   unsigned int jresult ;
79330   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79331   unsigned int result;
79332
79333   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79334   {
79335     try {
79336       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79337     } catch (std::out_of_range& e) {
79338       {
79339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79340       };
79341     } catch (std::exception& e) {
79342       {
79343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79344       };
79345     } catch (Dali::DaliException e) {
79346       {
79347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79348       };
79349     } catch (...) {
79350       {
79351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79352       };
79353     }
79354   }
79355
79356   jresult = result;
79357   return jresult;
79358 }
79359
79360
79361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79362   unsigned int jresult ;
79363   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79364   bool result;
79365
79366   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79367   {
79368     try {
79369       result = (bool)(arg1)->MoveFocusForward();
79370     } catch (std::out_of_range& e) {
79371       {
79372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79373       };
79374     } catch (std::exception& e) {
79375       {
79376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79377       };
79378     } catch (Dali::DaliException e) {
79379       {
79380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79381       };
79382     } catch (...) {
79383       {
79384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79385       };
79386     }
79387   }
79388
79389   jresult = result;
79390   return jresult;
79391 }
79392
79393
79394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79395   unsigned int jresult ;
79396   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79397   bool result;
79398
79399   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79400   {
79401     try {
79402       result = (bool)(arg1)->MoveFocusBackward();
79403     } catch (std::out_of_range& e) {
79404       {
79405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79406       };
79407     } catch (std::exception& e) {
79408       {
79409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79410       };
79411     } catch (Dali::DaliException e) {
79412       {
79413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79414       };
79415     } catch (...) {
79416       {
79417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79418       };
79419     }
79420   }
79421
79422   jresult = result;
79423   return jresult;
79424 }
79425
79426
79427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79428   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79429
79430   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79431   {
79432     try {
79433       (arg1)->ClearFocus();
79434     } catch (std::out_of_range& e) {
79435       {
79436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79437       };
79438     } catch (std::exception& e) {
79439       {
79440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79441       };
79442     } catch (Dali::DaliException e) {
79443       {
79444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79445       };
79446     } catch (...) {
79447       {
79448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79449       };
79450     }
79451   }
79452
79453 }
79454
79455
79456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79457   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79458
79459   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79460   {
79461     try {
79462       (arg1)->Reset();
79463     } catch (std::out_of_range& e) {
79464       {
79465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79466       };
79467     } catch (std::exception& e) {
79468       {
79469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79470       };
79471     } catch (Dali::DaliException e) {
79472       {
79473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79474       };
79475     } catch (...) {
79476       {
79477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79478       };
79479     }
79480   }
79481
79482 }
79483
79484
79485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79486   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79487   Dali::Actor arg2 ;
79488   bool arg3 ;
79489   Dali::Actor *argp2 ;
79490
79491   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79492   argp2 = (Dali::Actor *)jarg2;
79493   if (!argp2) {
79494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79495     return ;
79496   }
79497   arg2 = *argp2;
79498   arg3 = jarg3 ? true : false;
79499   {
79500     try {
79501       (arg1)->SetFocusGroup(arg2,arg3);
79502     } catch (std::out_of_range& e) {
79503       {
79504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79505       };
79506     } catch (std::exception& e) {
79507       {
79508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79509       };
79510     } catch (Dali::DaliException e) {
79511       {
79512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79513       };
79514     } catch (...) {
79515       {
79516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79517       };
79518     }
79519   }
79520
79521 }
79522
79523
79524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79525   unsigned int jresult ;
79526   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79527   Dali::Actor arg2 ;
79528   Dali::Actor *argp2 ;
79529   bool result;
79530
79531   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79532   argp2 = (Dali::Actor *)jarg2;
79533   if (!argp2) {
79534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79535     return 0;
79536   }
79537   arg2 = *argp2;
79538   {
79539     try {
79540       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79541     } catch (std::out_of_range& e) {
79542       {
79543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79544       };
79545     } catch (std::exception& e) {
79546       {
79547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79548       };
79549     } catch (Dali::DaliException e) {
79550       {
79551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79552       };
79553     } catch (...) {
79554       {
79555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79556       };
79557     }
79558   }
79559
79560   jresult = result;
79561   return jresult;
79562 }
79563
79564
79565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79566   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79567   bool arg2 ;
79568
79569   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79570   arg2 = jarg2 ? true : false;
79571   {
79572     try {
79573       (arg1)->SetGroupMode(arg2);
79574     } catch (std::out_of_range& e) {
79575       {
79576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79577       };
79578     } catch (std::exception& e) {
79579       {
79580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79581       };
79582     } catch (Dali::DaliException e) {
79583       {
79584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79585       };
79586     } catch (...) {
79587       {
79588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79589       };
79590     }
79591   }
79592
79593 }
79594
79595
79596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79597   unsigned int jresult ;
79598   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79599   bool result;
79600
79601   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79602   {
79603     try {
79604       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79605     } catch (std::out_of_range& e) {
79606       {
79607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79608       };
79609     } catch (std::exception& e) {
79610       {
79611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79612       };
79613     } catch (Dali::DaliException e) {
79614       {
79615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79616       };
79617     } catch (...) {
79618       {
79619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79620       };
79621     }
79622   }
79623
79624   jresult = result;
79625   return jresult;
79626 }
79627
79628
79629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79630   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79631   bool arg2 ;
79632
79633   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79634   arg2 = jarg2 ? true : false;
79635   {
79636     try {
79637       (arg1)->SetWrapMode(arg2);
79638     } catch (std::out_of_range& e) {
79639       {
79640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79641       };
79642     } catch (std::exception& e) {
79643       {
79644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79645       };
79646     } catch (Dali::DaliException e) {
79647       {
79648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79649       };
79650     } catch (...) {
79651       {
79652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79653       };
79654     }
79655   }
79656
79657 }
79658
79659
79660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
79661   unsigned int jresult ;
79662   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79663   bool result;
79664
79665   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79666   {
79667     try {
79668       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
79669     } catch (std::out_of_range& e) {
79670       {
79671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79672       };
79673     } catch (std::exception& e) {
79674       {
79675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79676       };
79677     } catch (Dali::DaliException e) {
79678       {
79679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79680       };
79681     } catch (...) {
79682       {
79683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79684       };
79685     }
79686   }
79687
79688   jresult = result;
79689   return jresult;
79690 }
79691
79692
79693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
79694   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79695   Dali::Actor arg2 ;
79696   Dali::Actor *argp2 ;
79697
79698   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79699   argp2 = (Dali::Actor *)jarg2;
79700   if (!argp2) {
79701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79702     return ;
79703   }
79704   arg2 = *argp2;
79705   {
79706     try {
79707       (arg1)->SetFocusIndicatorActor(arg2);
79708     } catch (std::out_of_range& e) {
79709       {
79710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79711       };
79712     } catch (std::exception& e) {
79713       {
79714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79715       };
79716     } catch (Dali::DaliException e) {
79717       {
79718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79719       };
79720     } catch (...) {
79721       {
79722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79723       };
79724     }
79725   }
79726
79727 }
79728
79729
79730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
79731   void * jresult ;
79732   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79733   Dali::Actor result;
79734
79735   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79736   {
79737     try {
79738       result = (arg1)->GetFocusIndicatorActor();
79739     } catch (std::out_of_range& e) {
79740       {
79741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79742       };
79743     } catch (std::exception& e) {
79744       {
79745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79746       };
79747     } catch (Dali::DaliException e) {
79748       {
79749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79750       };
79751     } catch (...) {
79752       {
79753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79754       };
79755     }
79756   }
79757
79758   jresult = new Dali::Actor((const Dali::Actor &)result);
79759   return jresult;
79760 }
79761
79762
79763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
79764   void * jresult ;
79765   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79766   Dali::Actor arg2 ;
79767   Dali::Actor *argp2 ;
79768   Dali::Actor result;
79769
79770   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79771   argp2 = (Dali::Actor *)jarg2;
79772   if (!argp2) {
79773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79774     return 0;
79775   }
79776   arg2 = *argp2;
79777   {
79778     try {
79779       result = (arg1)->GetFocusGroup(arg2);
79780     } catch (std::out_of_range& e) {
79781       {
79782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79783       };
79784     } catch (std::exception& e) {
79785       {
79786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79787       };
79788     } catch (Dali::DaliException e) {
79789       {
79790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79791       };
79792     } catch (...) {
79793       {
79794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79795       };
79796     }
79797   }
79798
79799   jresult = new Dali::Actor((const Dali::Actor &)result);
79800   return jresult;
79801 }
79802
79803
79804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79805   void * jresult ;
79806   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79807   Dali::Vector2 result;
79808
79809   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79810   {
79811     try {
79812       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79813     } catch (std::out_of_range& e) {
79814       {
79815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79816       };
79817     } catch (std::exception& e) {
79818       {
79819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79820       };
79821     } catch (Dali::DaliException e) {
79822       {
79823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79824       };
79825     } catch (...) {
79826       {
79827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79828       };
79829     }
79830   }
79831
79832   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79833   return jresult;
79834 }
79835
79836
79837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
79838   void * jresult ;
79839   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79840   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
79841
79842   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79843   {
79844     try {
79845       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
79846     } catch (std::out_of_range& e) {
79847       {
79848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79849       };
79850     } catch (std::exception& e) {
79851       {
79852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79853       };
79854     } catch (Dali::DaliException e) {
79855       {
79856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79857       };
79858     } catch (...) {
79859       {
79860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79861       };
79862     }
79863   }
79864
79865   jresult = (void *)result;
79866   return jresult;
79867 }
79868
79869
79870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
79871   void * jresult ;
79872   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79873   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
79874
79875   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79876   {
79877     try {
79878       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
79879     } catch (std::out_of_range& e) {
79880       {
79881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79882       };
79883     } catch (std::exception& e) {
79884       {
79885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79886       };
79887     } catch (Dali::DaliException e) {
79888       {
79889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79890       };
79891     } catch (...) {
79892       {
79893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79894       };
79895     }
79896   }
79897
79898   jresult = (void *)result;
79899   return jresult;
79900 }
79901
79902
79903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
79904   void * jresult ;
79905   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79906   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
79907
79908   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79909   {
79910     try {
79911       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
79912     } catch (std::out_of_range& e) {
79913       {
79914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79915       };
79916     } catch (std::exception& e) {
79917       {
79918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79919       };
79920     } catch (Dali::DaliException e) {
79921       {
79922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79923       };
79924     } catch (...) {
79925       {
79926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79927       };
79928     }
79929   }
79930
79931   jresult = (void *)result;
79932   return jresult;
79933 }
79934
79935
79936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
79937   void * jresult ;
79938   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79939   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79940
79941   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79942   {
79943     try {
79944       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
79945     } catch (std::out_of_range& e) {
79946       {
79947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79948       };
79949     } catch (std::exception& e) {
79950       {
79951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79952       };
79953     } catch (Dali::DaliException e) {
79954       {
79955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79956       };
79957     } catch (...) {
79958       {
79959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79960       };
79961     }
79962   }
79963
79964   jresult = (void *)result;
79965   return jresult;
79966 }
79967
79968
79969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
79970   void * jresult ;
79971   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79972   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79973
79974   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79975   {
79976     try {
79977       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
79978     } catch (std::out_of_range& e) {
79979       {
79980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79981       };
79982     } catch (std::exception& e) {
79983       {
79984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79985       };
79986     } catch (Dali::DaliException e) {
79987       {
79988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79989       };
79990     } catch (...) {
79991       {
79992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79993       };
79994     }
79995   }
79996
79997   jresult = (void *)result;
79998   return jresult;
79999 }
80000
80001
80002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80003   void * jresult ;
80004   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80005   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80006
80007   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80008   {
80009     try {
80010       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80011     } catch (std::out_of_range& e) {
80012       {
80013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80014       };
80015     } catch (std::exception& e) {
80016       {
80017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80018       };
80019     } catch (Dali::DaliException e) {
80020       {
80021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80022       };
80023     } catch (...) {
80024       {
80025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80026       };
80027     }
80028   }
80029
80030   jresult = (void *)result;
80031   return jresult;
80032 }
80033
80034
80035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80036   void * jresult ;
80037   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80038   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80039
80040   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80041   {
80042     try {
80043       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80044     } catch (std::out_of_range& e) {
80045       {
80046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80047       };
80048     } catch (std::exception& e) {
80049       {
80050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80051       };
80052     } catch (Dali::DaliException e) {
80053       {
80054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80055       };
80056     } catch (...) {
80057       {
80058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80059       };
80060     }
80061   }
80062
80063   jresult = (void *)result;
80064   return jresult;
80065 }
80066
80067
80068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80069   void * jresult ;
80070   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80071   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80072
80073   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80074   {
80075     try {
80076       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80077     } catch (std::out_of_range& e) {
80078       {
80079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80080       };
80081     } catch (std::exception& e) {
80082       {
80083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80084       };
80085     } catch (Dali::DaliException e) {
80086       {
80087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80088       };
80089     } catch (...) {
80090       {
80091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80092       };
80093     }
80094   }
80095
80096   jresult = (void *)result;
80097   return jresult;
80098 }
80099
80100
80101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80102   void * jresult ;
80103   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80104   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80105
80106   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80107   {
80108     try {
80109       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80110     } catch (std::out_of_range& e) {
80111       {
80112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80113       };
80114     } catch (std::exception& e) {
80115       {
80116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80117       };
80118     } catch (Dali::DaliException e) {
80119       {
80120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80121       };
80122     } catch (...) {
80123       {
80124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80125       };
80126     }
80127   }
80128
80129   jresult = (void *)result;
80130   return jresult;
80131 }
80132
80133
80134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80135   void * jresult ;
80136   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80137   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80138
80139   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80140   {
80141     try {
80142       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80143     } catch (std::out_of_range& e) {
80144       {
80145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80146       };
80147     } catch (std::exception& e) {
80148       {
80149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80150       };
80151     } catch (Dali::DaliException e) {
80152       {
80153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80154       };
80155     } catch (...) {
80156       {
80157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80158       };
80159     }
80160   }
80161
80162   jresult = (void *)result;
80163   return jresult;
80164 }
80165
80166
80167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80168   void * jresult ;
80169   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80170   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80171
80172   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80173   {
80174     try {
80175       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80176     } catch (std::out_of_range& e) {
80177       {
80178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80179       };
80180     } catch (std::exception& e) {
80181       {
80182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80183       };
80184     } catch (Dali::DaliException e) {
80185       {
80186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80187       };
80188     } catch (...) {
80189       {
80190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80191       };
80192     }
80193   }
80194
80195   jresult = (void *)result;
80196   return jresult;
80197 }
80198
80199
80200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80201   void * jresult ;
80202   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80203   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80204
80205   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80206   {
80207     try {
80208       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80209     } catch (std::out_of_range& e) {
80210       {
80211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80212       };
80213     } catch (std::exception& e) {
80214       {
80215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80216       };
80217     } catch (Dali::DaliException e) {
80218       {
80219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80220       };
80221     } catch (...) {
80222       {
80223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80224       };
80225     }
80226   }
80227
80228   jresult = (void *)result;
80229   return jresult;
80230 }
80231
80232
80233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80234   void * jresult ;
80235   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80236   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80237
80238   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80239   {
80240     try {
80241       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80242     } catch (std::out_of_range& e) {
80243       {
80244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80245       };
80246     } catch (std::exception& e) {
80247       {
80248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80249       };
80250     } catch (Dali::DaliException e) {
80251       {
80252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80253       };
80254     } catch (...) {
80255       {
80256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80257       };
80258     }
80259   }
80260
80261   jresult = (void *)result;
80262   return jresult;
80263 }
80264
80265
80266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80267   void * jresult ;
80268   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80269   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80270
80271   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80272   {
80273     try {
80274       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80275     } catch (std::out_of_range& e) {
80276       {
80277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80278       };
80279     } catch (std::exception& e) {
80280       {
80281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80282       };
80283     } catch (Dali::DaliException e) {
80284       {
80285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80286       };
80287     } catch (...) {
80288       {
80289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80290       };
80291     }
80292   }
80293
80294   jresult = (void *)result;
80295   return jresult;
80296 }
80297
80298
80299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
80300   void * jresult ;
80301   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80302   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80303
80304   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80305   {
80306     try {
80307       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80308     } catch (std::out_of_range& e) {
80309       {
80310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80311       };
80312     } catch (std::exception& e) {
80313       {
80314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80315       };
80316     } catch (Dali::DaliException e) {
80317       {
80318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80319       };
80320     } catch (...) {
80321       {
80322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80323       };
80324     }
80325   }
80326
80327   jresult = (void *)result;
80328   return jresult;
80329 }
80330
80331
80332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80333   void * jresult ;
80334   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80335   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80336
80337   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80338   {
80339     try {
80340       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80341     } catch (std::out_of_range& e) {
80342       {
80343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80344       };
80345     } catch (std::exception& e) {
80346       {
80347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80348       };
80349     } catch (Dali::DaliException e) {
80350       {
80351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80352       };
80353     } catch (...) {
80354       {
80355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80356       };
80357     }
80358   }
80359
80360   jresult = (void *)result;
80361   return jresult;
80362 }
80363
80364
80365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80366   void * jresult ;
80367   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80368   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80369
80370   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80371   {
80372     try {
80373       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80374     } catch (std::out_of_range& e) {
80375       {
80376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80377       };
80378     } catch (std::exception& e) {
80379       {
80380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80381       };
80382     } catch (Dali::DaliException e) {
80383       {
80384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80385       };
80386     } catch (...) {
80387       {
80388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80389       };
80390     }
80391   }
80392
80393   jresult = (void *)result;
80394   return jresult;
80395 }
80396
80397
80398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80399   void * jresult ;
80400   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80401   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80402
80403   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80404   {
80405     try {
80406       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80407     } catch (std::out_of_range& e) {
80408       {
80409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80410       };
80411     } catch (std::exception& e) {
80412       {
80413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80414       };
80415     } catch (Dali::DaliException e) {
80416       {
80417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80418       };
80419     } catch (...) {
80420       {
80421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80422       };
80423     }
80424   }
80425
80426   jresult = (void *)result;
80427   return jresult;
80428 }
80429
80430
80431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80432   void * jresult ;
80433   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80434   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80435
80436   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80437   {
80438     try {
80439       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80440     } catch (std::out_of_range& e) {
80441       {
80442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80443       };
80444     } catch (std::exception& e) {
80445       {
80446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80447       };
80448     } catch (Dali::DaliException e) {
80449       {
80450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80451       };
80452     } catch (...) {
80453       {
80454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80455       };
80456     }
80457   }
80458
80459   jresult = (void *)result;
80460   return jresult;
80461 }
80462
80463
80464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80465   void * jresult ;
80466   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80467   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80468
80469   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80470   {
80471     try {
80472       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
80473     } catch (std::out_of_range& e) {
80474       {
80475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80476       };
80477     } catch (std::exception& e) {
80478       {
80479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80480       };
80481     } catch (Dali::DaliException e) {
80482       {
80483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80484       };
80485     } catch (...) {
80486       {
80487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80488       };
80489     }
80490   }
80491
80492   jresult = (void *)result;
80493   return jresult;
80494 }
80495
80496
80497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
80498   void * jresult ;
80499   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80500   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80501
80502   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80503   {
80504     try {
80505       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
80506     } catch (std::out_of_range& e) {
80507       {
80508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80509       };
80510     } catch (std::exception& e) {
80511       {
80512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80513       };
80514     } catch (Dali::DaliException e) {
80515       {
80516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80517       };
80518     } catch (...) {
80519       {
80520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80521       };
80522     }
80523   }
80524
80525   jresult = (void *)result;
80526   return jresult;
80527 }
80528
80529
80530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80531   void * jresult ;
80532   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80533   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80534
80535   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80536   {
80537     try {
80538       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80539     } catch (std::out_of_range& e) {
80540       {
80541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80542       };
80543     } catch (std::exception& e) {
80544       {
80545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80546       };
80547     } catch (Dali::DaliException e) {
80548       {
80549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80550       };
80551     } catch (...) {
80552       {
80553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80554       };
80555     }
80556   }
80557
80558   jresult = (void *)result;
80559   return jresult;
80560 }
80561
80562
80563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80564   void * jresult ;
80565   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80566   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80567
80568   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80569   {
80570     try {
80571       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80572     } catch (std::out_of_range& e) {
80573       {
80574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80575       };
80576     } catch (std::exception& e) {
80577       {
80578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80579       };
80580     } catch (Dali::DaliException e) {
80581       {
80582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80583       };
80584     } catch (...) {
80585       {
80586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80587       };
80588     }
80589   }
80590
80591   jresult = (void *)result;
80592   return jresult;
80593 }
80594
80595
80596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80597   void * jresult ;
80598   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80599   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80600
80601   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80602   {
80603     try {
80604       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80605     } catch (std::out_of_range& e) {
80606       {
80607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80608       };
80609     } catch (std::exception& e) {
80610       {
80611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80612       };
80613     } catch (Dali::DaliException e) {
80614       {
80615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80616       };
80617     } catch (...) {
80618       {
80619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80620       };
80621     }
80622   }
80623
80624   jresult = (void *)result;
80625   return jresult;
80626 }
80627
80628
80629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80630   void * jresult ;
80631   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80632   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80633
80634   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80635   {
80636     try {
80637       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80638     } catch (std::out_of_range& e) {
80639       {
80640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80641       };
80642     } catch (std::exception& e) {
80643       {
80644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80645       };
80646     } catch (Dali::DaliException e) {
80647       {
80648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80649       };
80650     } catch (...) {
80651       {
80652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80653       };
80654     }
80655   }
80656
80657   jresult = (void *)result;
80658   return jresult;
80659 }
80660
80661
80662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80663   void * jresult ;
80664   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80665   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80666
80667   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80668   {
80669     try {
80670       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80671     } catch (std::out_of_range& e) {
80672       {
80673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80674       };
80675     } catch (std::exception& e) {
80676       {
80677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80678       };
80679     } catch (Dali::DaliException e) {
80680       {
80681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80682       };
80683     } catch (...) {
80684       {
80685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80686       };
80687     }
80688   }
80689
80690   jresult = (void *)result;
80691   return jresult;
80692 }
80693
80694
80695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
80696   void * jresult ;
80697   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80698   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80699
80700   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80701   {
80702     try {
80703       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
80704     } catch (std::out_of_range& e) {
80705       {
80706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80707       };
80708     } catch (std::exception& e) {
80709       {
80710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80711       };
80712     } catch (Dali::DaliException e) {
80713       {
80714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80715       };
80716     } catch (...) {
80717       {
80718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80719       };
80720     }
80721   }
80722
80723   jresult = (void *)result;
80724   return jresult;
80725 }
80726
80727
80728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
80729   void * jresult ;
80730   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80731   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80732
80733   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80734   {
80735     try {
80736       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
80737     } catch (std::out_of_range& e) {
80738       {
80739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80740       };
80741     } catch (std::exception& e) {
80742       {
80743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80744       };
80745     } catch (Dali::DaliException e) {
80746       {
80747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80748       };
80749     } catch (...) {
80750       {
80751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80752       };
80753     }
80754   }
80755
80756   jresult = (void *)result;
80757   return jresult;
80758 }
80759
80760
80761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
80762   void * jresult ;
80763   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80764   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
80765
80766   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80767   {
80768     try {
80769       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
80770     } catch (std::out_of_range& e) {
80771       {
80772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80773       };
80774     } catch (std::exception& e) {
80775       {
80776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80777       };
80778     } catch (Dali::DaliException e) {
80779       {
80780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80781       };
80782     } catch (...) {
80783       {
80784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80785       };
80786     }
80787   }
80788
80789   jresult = (void *)result;
80790   return jresult;
80791 }
80792
80793
80794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
80795   void * jresult ;
80796   Dali::Toolkit::StyleManager *result = 0 ;
80797
80798   {
80799     try {
80800       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
80801     } catch (std::out_of_range& e) {
80802       {
80803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80804       };
80805     } catch (std::exception& e) {
80806       {
80807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80808       };
80809     } catch (Dali::DaliException e) {
80810       {
80811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80812       };
80813     } catch (...) {
80814       {
80815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80816       };
80817     }
80818   }
80819
80820   jresult = (void *)result;
80821   return jresult;
80822 }
80823
80824
80825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
80826   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80827
80828   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80829   {
80830     try {
80831       delete arg1;
80832     } catch (std::out_of_range& e) {
80833       {
80834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80835       };
80836     } catch (std::exception& e) {
80837       {
80838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80839       };
80840     } catch (Dali::DaliException e) {
80841       {
80842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80843       };
80844     } catch (...) {
80845       {
80846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80847       };
80848     }
80849   }
80850
80851 }
80852
80853
80854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
80855   void * jresult ;
80856   Dali::Toolkit::StyleManager result;
80857
80858   {
80859     try {
80860       result = Dali::Toolkit::StyleManager::Get();
80861     } catch (std::out_of_range& e) {
80862       {
80863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80864       };
80865     } catch (std::exception& e) {
80866       {
80867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80868       };
80869     } catch (Dali::DaliException e) {
80870       {
80871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80872       };
80873     } catch (...) {
80874       {
80875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80876       };
80877     }
80878   }
80879
80880   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
80881   return jresult;
80882 }
80883
80884
80885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
80886   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80887   std::string *arg2 = 0 ;
80888
80889   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80890   if (!jarg2) {
80891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80892     return ;
80893   }
80894   std::string arg2_str(jarg2);
80895   arg2 = &arg2_str;
80896   {
80897     try {
80898       (arg1)->ApplyTheme((std::string const &)*arg2);
80899     } catch (std::out_of_range& e) {
80900       {
80901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80902       };
80903     } catch (std::exception& e) {
80904       {
80905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80906       };
80907     } catch (Dali::DaliException e) {
80908       {
80909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80910       };
80911     } catch (...) {
80912       {
80913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80914       };
80915     }
80916   }
80917
80918
80919   //argout typemap for const std::string&
80920
80921 }
80922
80923
80924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
80925   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80926
80927   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80928   {
80929     try {
80930       (arg1)->ApplyDefaultTheme();
80931     } catch (std::out_of_range& e) {
80932       {
80933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80934       };
80935     } catch (std::exception& e) {
80936       {
80937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80938       };
80939     } catch (Dali::DaliException e) {
80940       {
80941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80942       };
80943     } catch (...) {
80944       {
80945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80946       };
80947     }
80948   }
80949
80950 }
80951
80952
80953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80954   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80955   std::string *arg2 = 0 ;
80956   Dali::Property::Value *arg3 = 0 ;
80957
80958   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80959   if (!jarg2) {
80960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80961     return ;
80962   }
80963   std::string arg2_str(jarg2);
80964   arg2 = &arg2_str;
80965   arg3 = (Dali::Property::Value *)jarg3;
80966   if (!arg3) {
80967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
80968     return ;
80969   }
80970   {
80971     try {
80972       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
80973     } catch (std::out_of_range& e) {
80974       {
80975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80976       };
80977     } catch (std::exception& e) {
80978       {
80979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80980       };
80981     } catch (Dali::DaliException e) {
80982       {
80983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80984       };
80985     } catch (...) {
80986       {
80987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80988       };
80989     }
80990   }
80991
80992
80993   //argout typemap for const std::string&
80994
80995 }
80996
80997
80998 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80999   unsigned int jresult ;
81000   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81001   std::string *arg2 = 0 ;
81002   Dali::Property::Value *arg3 = 0 ;
81003   bool result;
81004
81005   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81006   if (!jarg2) {
81007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81008     return 0;
81009   }
81010   std::string arg2_str(jarg2);
81011   arg2 = &arg2_str;
81012   arg3 = (Dali::Property::Value *)jarg3;
81013   if (!arg3) {
81014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81015     return 0;
81016   }
81017   {
81018     try {
81019       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81020     } catch (std::out_of_range& e) {
81021       {
81022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81023       };
81024     } catch (std::exception& e) {
81025       {
81026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81027       };
81028     } catch (Dali::DaliException e) {
81029       {
81030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81031       };
81032     } catch (...) {
81033       {
81034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81035       };
81036     }
81037   }
81038
81039   jresult = result;
81040
81041   //argout typemap for const std::string&
81042
81043   return jresult;
81044 }
81045
81046
81047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81048   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81049   Dali::Toolkit::Control arg2 ;
81050   std::string *arg3 = 0 ;
81051   std::string *arg4 = 0 ;
81052   Dali::Toolkit::Control *argp2 ;
81053
81054   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81055   argp2 = (Dali::Toolkit::Control *)jarg2;
81056   if (!argp2) {
81057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81058     return ;
81059   }
81060   arg2 = *argp2;
81061   if (!jarg3) {
81062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81063     return ;
81064   }
81065   std::string arg3_str(jarg3);
81066   arg3 = &arg3_str;
81067   if (!jarg4) {
81068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81069     return ;
81070   }
81071   std::string arg4_str(jarg4);
81072   arg4 = &arg4_str;
81073   {
81074     try {
81075       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81076     } catch (std::out_of_range& e) {
81077       {
81078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81079       };
81080     } catch (std::exception& e) {
81081       {
81082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81083       };
81084     } catch (Dali::DaliException e) {
81085       {
81086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81087       };
81088     } catch (...) {
81089       {
81090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81091       };
81092     }
81093   }
81094
81095
81096   //argout typemap for const std::string&
81097
81098
81099   //argout typemap for const std::string&
81100
81101 }
81102
81103
81104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81105   void * jresult ;
81106   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81107   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81108
81109   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81110   {
81111     try {
81112       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
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 = (void *)result;
81133   return jresult;
81134 }
81135
81136
81137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81138   int jresult ;
81139   int result;
81140
81141   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81142   jresult = (int)result;
81143   return jresult;
81144 }
81145
81146
81147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81148   int jresult ;
81149   int result;
81150
81151   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81152   jresult = (int)result;
81153   return jresult;
81154 }
81155
81156
81157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81158   int jresult ;
81159   int result;
81160
81161   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81162   jresult = (int)result;
81163   return jresult;
81164 }
81165
81166
81167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81168   int jresult ;
81169   int result;
81170
81171   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81172   jresult = (int)result;
81173   return jresult;
81174 }
81175
81176
81177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81178   int jresult ;
81179   int result;
81180
81181   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81182   jresult = (int)result;
81183   return jresult;
81184 }
81185
81186
81187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81188   int jresult ;
81189   int result;
81190
81191   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81192   jresult = (int)result;
81193   return jresult;
81194 }
81195
81196
81197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81198   int jresult ;
81199   int result;
81200
81201   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81202   jresult = (int)result;
81203   return jresult;
81204 }
81205
81206
81207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81208   int jresult ;
81209   int result;
81210
81211   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81212   jresult = (int)result;
81213   return jresult;
81214 }
81215
81216
81217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81218   int jresult ;
81219   int result;
81220
81221   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81222   jresult = (int)result;
81223   return jresult;
81224 }
81225
81226
81227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81228   int jresult ;
81229   int result;
81230
81231   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81232   jresult = (int)result;
81233   return jresult;
81234 }
81235
81236
81237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81238   int jresult ;
81239   int result;
81240
81241   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81242   jresult = (int)result;
81243   return jresult;
81244 }
81245
81246
81247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81248   int jresult ;
81249   int result;
81250
81251   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81252   jresult = (int)result;
81253   return jresult;
81254 }
81255
81256
81257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81258   int jresult ;
81259   int result;
81260
81261   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81262   jresult = (int)result;
81263   return jresult;
81264 }
81265
81266
81267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81268   int jresult ;
81269   int result;
81270
81271   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81272   jresult = (int)result;
81273   return jresult;
81274 }
81275
81276
81277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81278   int jresult ;
81279   int result;
81280
81281   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81282   jresult = (int)result;
81283   return jresult;
81284 }
81285
81286
81287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81288   void * jresult ;
81289   Dali::Toolkit::Slider::Property *result = 0 ;
81290
81291   {
81292     try {
81293       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81294     } catch (std::out_of_range& e) {
81295       {
81296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81297       };
81298     } catch (std::exception& e) {
81299       {
81300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81301       };
81302     } catch (Dali::DaliException e) {
81303       {
81304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81305       };
81306     } catch (...) {
81307       {
81308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81309       };
81310     }
81311   }
81312
81313   jresult = (void *)result;
81314   return jresult;
81315 }
81316
81317
81318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81319   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81320
81321   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81322   {
81323     try {
81324       delete arg1;
81325     } catch (std::out_of_range& e) {
81326       {
81327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81328       };
81329     } catch (std::exception& e) {
81330       {
81331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81332       };
81333     } catch (Dali::DaliException e) {
81334       {
81335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81336       };
81337     } catch (...) {
81338       {
81339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81340       };
81341     }
81342   }
81343
81344 }
81345
81346
81347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81348   void * jresult ;
81349   Dali::Toolkit::Slider result;
81350
81351   {
81352     try {
81353       result = Dali::Toolkit::Slider::New();
81354     } catch (std::out_of_range& e) {
81355       {
81356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81357       };
81358     } catch (std::exception& e) {
81359       {
81360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81361       };
81362     } catch (Dali::DaliException e) {
81363       {
81364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81365       };
81366     } catch (...) {
81367       {
81368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81369       };
81370     }
81371   }
81372
81373   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81374   return jresult;
81375 }
81376
81377
81378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81379   void * jresult ;
81380   Dali::Toolkit::Slider *result = 0 ;
81381
81382   {
81383     try {
81384       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81385     } catch (std::out_of_range& e) {
81386       {
81387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81388       };
81389     } catch (std::exception& e) {
81390       {
81391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81392       };
81393     } catch (Dali::DaliException e) {
81394       {
81395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81396       };
81397     } catch (...) {
81398       {
81399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81400       };
81401     }
81402   }
81403
81404   jresult = (void *)result;
81405   return jresult;
81406 }
81407
81408
81409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
81410   void * jresult ;
81411   Dali::Toolkit::Slider *arg1 = 0 ;
81412   Dali::Toolkit::Slider *result = 0 ;
81413
81414   arg1 = (Dali::Toolkit::Slider *)jarg1;
81415   if (!arg1) {
81416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81417     return 0;
81418   }
81419   {
81420     try {
81421       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81422     } catch (std::out_of_range& e) {
81423       {
81424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81425       };
81426     } catch (std::exception& e) {
81427       {
81428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81429       };
81430     } catch (Dali::DaliException e) {
81431       {
81432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81433       };
81434     } catch (...) {
81435       {
81436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81437       };
81438     }
81439   }
81440
81441   jresult = (void *)result;
81442   return jresult;
81443 }
81444
81445
81446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
81447   void * jresult ;
81448   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81449   Dali::Toolkit::Slider *arg2 = 0 ;
81450   Dali::Toolkit::Slider *result = 0 ;
81451
81452   arg1 = (Dali::Toolkit::Slider *)jarg1;
81453   arg2 = (Dali::Toolkit::Slider *)jarg2;
81454   if (!arg2) {
81455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81456     return 0;
81457   }
81458   {
81459     try {
81460       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81461     } catch (std::out_of_range& e) {
81462       {
81463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81464       };
81465     } catch (std::exception& e) {
81466       {
81467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81468       };
81469     } catch (Dali::DaliException e) {
81470       {
81471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81472       };
81473     } catch (...) {
81474       {
81475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81476       };
81477     }
81478   }
81479
81480   jresult = (void *)result;
81481   return jresult;
81482 }
81483
81484
81485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
81486   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81487
81488   arg1 = (Dali::Toolkit::Slider *)jarg1;
81489   {
81490     try {
81491       delete arg1;
81492     } catch (std::out_of_range& e) {
81493       {
81494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81495       };
81496     } catch (std::exception& e) {
81497       {
81498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81499       };
81500     } catch (Dali::DaliException e) {
81501       {
81502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81503       };
81504     } catch (...) {
81505       {
81506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81507       };
81508     }
81509   }
81510
81511 }
81512
81513
81514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
81515   void * jresult ;
81516   Dali::BaseHandle arg1 ;
81517   Dali::BaseHandle *argp1 ;
81518   Dali::Toolkit::Slider result;
81519
81520   argp1 = (Dali::BaseHandle *)jarg1;
81521   if (!argp1) {
81522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81523     return 0;
81524   }
81525   arg1 = *argp1;
81526   {
81527     try {
81528       result = Dali::Toolkit::Slider::DownCast(arg1);
81529     } catch (std::out_of_range& e) {
81530       {
81531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81532       };
81533     } catch (std::exception& e) {
81534       {
81535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81536       };
81537     } catch (Dali::DaliException e) {
81538       {
81539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81540       };
81541     } catch (...) {
81542       {
81543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81544       };
81545     }
81546   }
81547
81548   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81549   return jresult;
81550 }
81551
81552
81553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
81554   void * jresult ;
81555   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81556   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81557
81558   arg1 = (Dali::Toolkit::Slider *)jarg1;
81559   {
81560     try {
81561       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
81562     } catch (std::out_of_range& e) {
81563       {
81564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81565       };
81566     } catch (std::exception& e) {
81567       {
81568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81569       };
81570     } catch (Dali::DaliException e) {
81571       {
81572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81573       };
81574     } catch (...) {
81575       {
81576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81577       };
81578     }
81579   }
81580
81581   jresult = (void *)result;
81582   return jresult;
81583 }
81584
81585
81586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
81587   void * jresult ;
81588   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81589   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81590
81591   arg1 = (Dali::Toolkit::Slider *)jarg1;
81592   {
81593     try {
81594       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
81595     } catch (std::out_of_range& e) {
81596       {
81597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81598       };
81599     } catch (std::exception& e) {
81600       {
81601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81602       };
81603     } catch (Dali::DaliException e) {
81604       {
81605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81606       };
81607     } catch (...) {
81608       {
81609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81610       };
81611     }
81612   }
81613
81614   jresult = (void *)result;
81615   return jresult;
81616 }
81617
81618
81619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
81620   void * jresult ;
81621   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81622   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
81623
81624   arg1 = (Dali::Toolkit::Slider *)jarg1;
81625   {
81626     try {
81627       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
81628     } catch (std::out_of_range& e) {
81629       {
81630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81631       };
81632     } catch (std::exception& e) {
81633       {
81634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81635       };
81636     } catch (Dali::DaliException e) {
81637       {
81638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81639       };
81640     } catch (...) {
81641       {
81642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81643       };
81644     }
81645   }
81646
81647   jresult = (void *)result;
81648   return jresult;
81649 }
81650
81651
81652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
81653   int jresult ;
81654   int result;
81655
81656   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81657   jresult = (int)result;
81658   return jresult;
81659 }
81660
81661
81662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
81663   int jresult ;
81664   int result;
81665
81666   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81667   jresult = (int)result;
81668   return jresult;
81669 }
81670
81671
81672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
81673   int jresult ;
81674   int result;
81675
81676   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81677   jresult = (int)result;
81678   return jresult;
81679 }
81680
81681
81682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
81683   int jresult ;
81684   int result;
81685
81686   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81687   jresult = (int)result;
81688   return jresult;
81689 }
81690
81691
81692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
81693   int result;
81694
81695   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
81696
81697   return result;
81698 }
81699
81700
81701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
81702   void * jresult ;
81703   Dali::Toolkit::VideoView::Property *result = 0 ;
81704
81705   {
81706     try {
81707       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
81708     } catch (std::out_of_range& e) {
81709       {
81710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81711       };
81712     } catch (std::exception& e) {
81713       {
81714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81715       };
81716     } catch (Dali::DaliException e) {
81717       {
81718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81719       };
81720     } catch (...) {
81721       {
81722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81723       };
81724     }
81725   }
81726
81727   jresult = (void *)result;
81728   return jresult;
81729 }
81730
81731
81732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
81733   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81734
81735   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
81736   {
81737     try {
81738       delete arg1;
81739     } catch (std::out_of_range& e) {
81740       {
81741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81742       };
81743     } catch (std::exception& e) {
81744       {
81745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81746       };
81747     } catch (Dali::DaliException e) {
81748       {
81749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81750       };
81751     } catch (...) {
81752       {
81753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81754       };
81755     }
81756   }
81757
81758 }
81759
81760
81761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
81762   void * jresult ;
81763   Dali::Toolkit::VideoView result;
81764
81765   {
81766     try {
81767       result = Dali::Toolkit::VideoView::New();
81768     } catch (std::out_of_range& e) {
81769       {
81770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81771       };
81772     } catch (std::exception& e) {
81773       {
81774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81775       };
81776     } catch (Dali::DaliException e) {
81777       {
81778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81779       };
81780     } catch (...) {
81781       {
81782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81783       };
81784     }
81785   }
81786
81787   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81788   return jresult;
81789 }
81790
81791
81792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
81793   void * jresult ;
81794   std::string *arg1 = 0 ;
81795   Dali::Toolkit::VideoView result;
81796
81797   if (!jarg1) {
81798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81799     return 0;
81800   }
81801   std::string arg1_str(jarg1);
81802   arg1 = &arg1_str;
81803   {
81804     try {
81805       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81806     } catch (std::out_of_range& e) {
81807       {
81808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81809       };
81810     } catch (std::exception& e) {
81811       {
81812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81813       };
81814     } catch (Dali::DaliException e) {
81815       {
81816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81817       };
81818     } catch (...) {
81819       {
81820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81821       };
81822     }
81823   }
81824
81825   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81826
81827   //argout typemap for const std::string&
81828
81829   return jresult;
81830 }
81831
81832
81833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
81834   void * jresult ;
81835   Dali::Toolkit::VideoView result;
81836   {
81837     try {
81838       result = Dali::Toolkit::VideoView::New(swCodec);
81839     } catch (std::out_of_range& e) {
81840       {
81841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81842       };
81843     } catch (std::exception& e) {
81844       {
81845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81846       };
81847     } catch (Dali::DaliException e) {
81848       {
81849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81850       };
81851     } catch (...) {
81852       {
81853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81854       };
81855     }
81856   }
81857
81858   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81859
81860   //argout typemap for const std::string&
81861
81862   return jresult;
81863 }
81864
81865
81866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
81867   void * jresult ;
81868   std::string *arg1 = 0 ;
81869   Dali::Toolkit::VideoView result;
81870
81871   if (!jarg1) {
81872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81873     return 0;
81874   }
81875   std::string arg1_str(jarg1);
81876   arg1 = &arg1_str;
81877   {
81878     try {
81879       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
81880     } catch (std::out_of_range& e) {
81881       {
81882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81883       };
81884     } catch (std::exception& e) {
81885       {
81886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81887       };
81888     } catch (Dali::DaliException e) {
81889       {
81890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81891       };
81892     } catch (...) {
81893       {
81894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81895       };
81896     }
81897   }
81898
81899   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81900
81901   //argout typemap for const std::string&
81902
81903   return jresult;
81904 }
81905
81906
81907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
81908   void * jresult ;
81909   Dali::Toolkit::VideoView *result = 0 ;
81910
81911   {
81912     try {
81913       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
81914     } catch (std::out_of_range& e) {
81915       {
81916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81917       };
81918     } catch (std::exception& e) {
81919       {
81920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81921       };
81922     } catch (Dali::DaliException e) {
81923       {
81924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81925       };
81926     } catch (...) {
81927       {
81928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81929       };
81930     }
81931   }
81932
81933   jresult = (void *)result;
81934   return jresult;
81935 }
81936
81937
81938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
81939   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81940
81941   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81942   {
81943     try {
81944       delete arg1;
81945     } catch (std::out_of_range& e) {
81946       {
81947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81948       };
81949     } catch (std::exception& e) {
81950       {
81951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81952       };
81953     } catch (Dali::DaliException e) {
81954       {
81955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81956       };
81957     } catch (...) {
81958       {
81959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81960       };
81961     }
81962   }
81963
81964 }
81965
81966
81967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
81968   void * jresult ;
81969   Dali::Toolkit::VideoView *arg1 = 0 ;
81970   Dali::Toolkit::VideoView *result = 0 ;
81971
81972   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81973   if (!arg1) {
81974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81975     return 0;
81976   }
81977   {
81978     try {
81979       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
81980     } catch (std::out_of_range& e) {
81981       {
81982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81983       };
81984     } catch (std::exception& e) {
81985       {
81986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81987       };
81988     } catch (Dali::DaliException e) {
81989       {
81990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81991       };
81992     } catch (...) {
81993       {
81994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81995       };
81996     }
81997   }
81998
81999   jresult = (void *)result;
82000   return jresult;
82001 }
82002
82003
82004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82005   void * jresult ;
82006   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82007   Dali::Toolkit::VideoView *arg2 = 0 ;
82008   Dali::Toolkit::VideoView *result = 0 ;
82009
82010   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82011   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82012   if (!arg2) {
82013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82014     return 0;
82015   }
82016   {
82017     try {
82018       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82019     } catch (std::out_of_range& e) {
82020       {
82021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82022       };
82023     } catch (std::exception& e) {
82024       {
82025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82026       };
82027     } catch (Dali::DaliException e) {
82028       {
82029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82030       };
82031     } catch (...) {
82032       {
82033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82034       };
82035     }
82036   }
82037
82038   jresult = (void *)result;
82039   return jresult;
82040 }
82041
82042
82043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82044   void * jresult ;
82045   Dali::BaseHandle arg1 ;
82046   Dali::BaseHandle *argp1 ;
82047   Dali::Toolkit::VideoView result;
82048
82049   argp1 = (Dali::BaseHandle *)jarg1;
82050   if (!argp1) {
82051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82052     return 0;
82053   }
82054   arg1 = *argp1;
82055   {
82056     try {
82057       result = Dali::Toolkit::VideoView::DownCast(arg1);
82058     } catch (std::out_of_range& e) {
82059       {
82060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82061       };
82062     } catch (std::exception& e) {
82063       {
82064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82065       };
82066     } catch (Dali::DaliException e) {
82067       {
82068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82069       };
82070     } catch (...) {
82071       {
82072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82073       };
82074     }
82075   }
82076
82077   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82078   return jresult;
82079 }
82080
82081
82082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82083   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82084
82085   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82086   {
82087     try {
82088       (arg1)->Play();
82089     } catch (std::out_of_range& e) {
82090       {
82091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82092       };
82093     } catch (std::exception& e) {
82094       {
82095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82096       };
82097     } catch (Dali::DaliException e) {
82098       {
82099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82100       };
82101     } catch (...) {
82102       {
82103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82104       };
82105     }
82106   }
82107
82108 }
82109
82110
82111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82112   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82113
82114   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82115   {
82116     try {
82117       (arg1)->Pause();
82118     } catch (std::out_of_range& e) {
82119       {
82120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82121       };
82122     } catch (std::exception& e) {
82123       {
82124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82125       };
82126     } catch (Dali::DaliException e) {
82127       {
82128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82129       };
82130     } catch (...) {
82131       {
82132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82133       };
82134     }
82135   }
82136
82137 }
82138
82139
82140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82141   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82142
82143   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82144   {
82145     try {
82146       (arg1)->Stop();
82147     } catch (std::out_of_range& e) {
82148       {
82149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82150       };
82151     } catch (std::exception& e) {
82152       {
82153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82154       };
82155     } catch (Dali::DaliException e) {
82156       {
82157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82158       };
82159     } catch (...) {
82160       {
82161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82162       };
82163     }
82164   }
82165
82166 }
82167
82168
82169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82170   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82171   int arg2 ;
82172
82173   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82174   arg2 = (int)jarg2;
82175   {
82176     try {
82177       (arg1)->Forward(arg2);
82178     } catch (std::out_of_range& e) {
82179       {
82180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82181       };
82182     } catch (std::exception& e) {
82183       {
82184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82185       };
82186     } catch (Dali::DaliException e) {
82187       {
82188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82189       };
82190     } catch (...) {
82191       {
82192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82193       };
82194     }
82195   }
82196
82197 }
82198
82199
82200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82201   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82202   int arg2 ;
82203
82204   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82205   arg2 = (int)jarg2;
82206   {
82207     try {
82208       (arg1)->Backward(arg2);
82209     } catch (std::out_of_range& e) {
82210       {
82211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82212       };
82213     } catch (std::exception& e) {
82214       {
82215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82216       };
82217     } catch (Dali::DaliException e) {
82218       {
82219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82220       };
82221     } catch (...) {
82222       {
82223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82224       };
82225     }
82226   }
82227
82228 }
82229
82230
82231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82232   void * jresult ;
82233   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82234   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82235
82236   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82237   {
82238     try {
82239       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82240     } catch (std::out_of_range& e) {
82241       {
82242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82243       };
82244     } catch (std::exception& e) {
82245       {
82246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82247       };
82248     } catch (Dali::DaliException e) {
82249       {
82250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82251       };
82252     } catch (...) {
82253       {
82254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82255       };
82256     }
82257   }
82258
82259   jresult = (void *)result;
82260   return jresult;
82261 }
82262
82263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
82264 {
82265   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
82266   if( arg1 == nullptr )
82267   {
82268     DALI_LOG_ERROR("VideoView is nullptr!");
82269     return nullptr;
82270   }
82271   void * ret = nullptr;
82272   {
82273     try{
82274
82275       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
82276       ret = Dali::AnyCast< void * >( result );
82277
82278     } catch (std::out_of_range& e) {
82279       {
82280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82281       };
82282     } catch (std::exception& e) {
82283       {
82284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82285       };
82286     } catch (Dali::DaliException e) {
82287       {
82288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82289       };
82290     } catch (...) {
82291       {
82292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82293       };
82294     }
82295   }
82296   return ret;
82297 }
82298
82299
82300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82301   int jresult ;
82302   int result;
82303
82304   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82305   jresult = (int)result;
82306   return jresult;
82307 }
82308
82309
82310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82311   int jresult ;
82312   int result;
82313
82314   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82315   jresult = (int)result;
82316   return jresult;
82317 }
82318
82319
82320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82321   int jresult ;
82322   int result;
82323
82324   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82325   jresult = (int)result;
82326   return jresult;
82327 }
82328
82329
82330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82331   int jresult ;
82332   int result;
82333
82334   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82335   jresult = (int)result;
82336   return jresult;
82337 }
82338
82339
82340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82341   int jresult ;
82342   int result;
82343
82344   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82345   jresult = (int)result;
82346   return jresult;
82347 }
82348
82349
82350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82351   int jresult ;
82352   int result;
82353
82354   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82355   jresult = (int)result;
82356   return jresult;
82357 }
82358
82359
82360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82361   int jresult ;
82362   int result;
82363
82364   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82365   jresult = (int)result;
82366   return jresult;
82367 }
82368
82369
82370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82371   int jresult ;
82372   int result;
82373
82374   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82375   jresult = (int)result;
82376   return jresult;
82377 }
82378
82379
82380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82381   int jresult ;
82382   int result;
82383
82384   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82385   jresult = (int)result;
82386   return jresult;
82387 }
82388
82389
82390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82391   int jresult ;
82392   int result;
82393
82394   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82395   jresult = (int)result;
82396   return jresult;
82397 }
82398
82399
82400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82401   int jresult ;
82402   int result;
82403
82404   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82405   jresult = (int)result;
82406   return jresult;
82407 }
82408
82409
82410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82411   int jresult ;
82412   int result;
82413
82414   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82415   jresult = (int)result;
82416   return jresult;
82417 }
82418
82419
82420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82421   int jresult ;
82422   int result;
82423
82424   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82425   jresult = (int)result;
82426   return jresult;
82427 }
82428
82429
82430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82431   int jresult ;
82432   int result;
82433
82434   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82435   jresult = (int)result;
82436   return jresult;
82437 }
82438
82439
82440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82441   int jresult ;
82442   int result;
82443
82444   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82445   jresult = (int)result;
82446   return jresult;
82447 }
82448
82449
82450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82451   int jresult ;
82452   int result;
82453
82454   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82455   jresult = (int)result;
82456   return jresult;
82457 }
82458
82459
82460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82461   int jresult ;
82462   int result;
82463
82464   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82465   jresult = (int)result;
82466   return jresult;
82467 }
82468
82469
82470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82471   int jresult ;
82472   int result;
82473
82474   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82475   jresult = (int)result;
82476   return jresult;
82477 }
82478
82479
82480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82481   int jresult ;
82482   int result;
82483
82484   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82485   jresult = (int)result;
82486   return jresult;
82487 }
82488
82489
82490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82491   int jresult ;
82492   int result;
82493
82494   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82495   jresult = (int)result;
82496   return jresult;
82497 }
82498
82499
82500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82501   int jresult ;
82502   int result;
82503
82504   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82505   jresult = (int)result;
82506   return jresult;
82507 }
82508
82509
82510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82511   void * jresult ;
82512   Dali::Toolkit::Popup::Property *result = 0 ;
82513
82514   {
82515     try {
82516       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82517     } catch (std::out_of_range& e) {
82518       {
82519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82520       };
82521     } catch (std::exception& e) {
82522       {
82523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82524       };
82525     } catch (Dali::DaliException e) {
82526       {
82527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82528       };
82529     } catch (...) {
82530       {
82531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82532       };
82533     }
82534   }
82535
82536   jresult = (void *)result;
82537   return jresult;
82538 }
82539
82540
82541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82542   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82543
82544   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82545   {
82546     try {
82547       delete arg1;
82548     } catch (std::out_of_range& e) {
82549       {
82550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82551       };
82552     } catch (std::exception& e) {
82553       {
82554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82555       };
82556     } catch (Dali::DaliException e) {
82557       {
82558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82559       };
82560     } catch (...) {
82561       {
82562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82563       };
82564     }
82565   }
82566
82567 }
82568
82569
82570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82571   void * jresult ;
82572   Dali::Toolkit::Popup *result = 0 ;
82573
82574   {
82575     try {
82576       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82577     } catch (std::out_of_range& e) {
82578       {
82579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82580       };
82581     } catch (std::exception& e) {
82582       {
82583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82584       };
82585     } catch (Dali::DaliException e) {
82586       {
82587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82588       };
82589     } catch (...) {
82590       {
82591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82592       };
82593     }
82594   }
82595
82596   jresult = (void *)result;
82597   return jresult;
82598 }
82599
82600
82601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82602   void * jresult ;
82603   Dali::Toolkit::Popup result;
82604
82605   {
82606     try {
82607       result = Dali::Toolkit::Popup::New();
82608     } catch (std::out_of_range& e) {
82609       {
82610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82611       };
82612     } catch (std::exception& e) {
82613       {
82614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82615       };
82616     } catch (Dali::DaliException e) {
82617       {
82618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82619       };
82620     } catch (...) {
82621       {
82622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82623       };
82624     }
82625   }
82626
82627   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82628   return jresult;
82629 }
82630
82631
82632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82633   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82634
82635   arg1 = (Dali::Toolkit::Popup *)jarg1;
82636   {
82637     try {
82638       delete arg1;
82639     } catch (std::out_of_range& e) {
82640       {
82641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82642       };
82643     } catch (std::exception& e) {
82644       {
82645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82646       };
82647     } catch (Dali::DaliException e) {
82648       {
82649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82650       };
82651     } catch (...) {
82652       {
82653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82654       };
82655     }
82656   }
82657
82658 }
82659
82660
82661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
82662   void * jresult ;
82663   Dali::Toolkit::Popup *arg1 = 0 ;
82664   Dali::Toolkit::Popup *result = 0 ;
82665
82666   arg1 = (Dali::Toolkit::Popup *)jarg1;
82667   if (!arg1) {
82668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82669     return 0;
82670   }
82671   {
82672     try {
82673       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
82674     } catch (std::out_of_range& e) {
82675       {
82676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82677       };
82678     } catch (std::exception& e) {
82679       {
82680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82681       };
82682     } catch (Dali::DaliException e) {
82683       {
82684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82685       };
82686     } catch (...) {
82687       {
82688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82689       };
82690     }
82691   }
82692
82693   jresult = (void *)result;
82694   return jresult;
82695 }
82696
82697
82698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
82699   void * jresult ;
82700   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82701   Dali::Toolkit::Popup *arg2 = 0 ;
82702   Dali::Toolkit::Popup *result = 0 ;
82703
82704   arg1 = (Dali::Toolkit::Popup *)jarg1;
82705   arg2 = (Dali::Toolkit::Popup *)jarg2;
82706   if (!arg2) {
82707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82708     return 0;
82709   }
82710   {
82711     try {
82712       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
82713     } catch (std::out_of_range& e) {
82714       {
82715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82716       };
82717     } catch (std::exception& e) {
82718       {
82719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82720       };
82721     } catch (Dali::DaliException e) {
82722       {
82723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82724       };
82725     } catch (...) {
82726       {
82727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82728       };
82729     }
82730   }
82731
82732   jresult = (void *)result;
82733   return jresult;
82734 }
82735
82736
82737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
82738   void * jresult ;
82739   Dali::BaseHandle arg1 ;
82740   Dali::BaseHandle *argp1 ;
82741   Dali::Toolkit::Popup result;
82742
82743   argp1 = (Dali::BaseHandle *)jarg1;
82744   if (!argp1) {
82745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82746     return 0;
82747   }
82748   arg1 = *argp1;
82749   {
82750     try {
82751       result = Dali::Toolkit::Popup::DownCast(arg1);
82752     } catch (std::out_of_range& e) {
82753       {
82754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82755       };
82756     } catch (std::exception& e) {
82757       {
82758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82759       };
82760     } catch (Dali::DaliException e) {
82761       {
82762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82763       };
82764     } catch (...) {
82765       {
82766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82767       };
82768     }
82769   }
82770
82771   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82772   return jresult;
82773 }
82774
82775
82776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
82777   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82778   Dali::Actor arg2 ;
82779   Dali::Actor *argp2 ;
82780
82781   arg1 = (Dali::Toolkit::Popup *)jarg1;
82782   argp2 = (Dali::Actor *)jarg2;
82783   if (!argp2) {
82784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82785     return ;
82786   }
82787   arg2 = *argp2;
82788   {
82789     try {
82790       (arg1)->SetTitle(arg2);
82791     } catch (std::out_of_range& e) {
82792       {
82793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82794       };
82795     } catch (std::exception& e) {
82796       {
82797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82798       };
82799     } catch (Dali::DaliException e) {
82800       {
82801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82802       };
82803     } catch (...) {
82804       {
82805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82806       };
82807     }
82808   }
82809
82810 }
82811
82812
82813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
82814   void * jresult ;
82815   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82816   Dali::Actor result;
82817
82818   arg1 = (Dali::Toolkit::Popup *)jarg1;
82819   {
82820     try {
82821       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
82822     } catch (std::out_of_range& e) {
82823       {
82824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82825       };
82826     } catch (std::exception& e) {
82827       {
82828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82829       };
82830     } catch (Dali::DaliException e) {
82831       {
82832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82833       };
82834     } catch (...) {
82835       {
82836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82837       };
82838     }
82839   }
82840
82841   jresult = new Dali::Actor((const Dali::Actor &)result);
82842   return jresult;
82843 }
82844
82845
82846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
82847   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82848   Dali::Actor arg2 ;
82849   Dali::Actor *argp2 ;
82850
82851   arg1 = (Dali::Toolkit::Popup *)jarg1;
82852   argp2 = (Dali::Actor *)jarg2;
82853   if (!argp2) {
82854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82855     return ;
82856   }
82857   arg2 = *argp2;
82858   {
82859     try {
82860       (arg1)->SetContent(arg2);
82861     } catch (std::out_of_range& e) {
82862       {
82863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82864       };
82865     } catch (std::exception& e) {
82866       {
82867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82868       };
82869     } catch (Dali::DaliException e) {
82870       {
82871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82872       };
82873     } catch (...) {
82874       {
82875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82876       };
82877     }
82878   }
82879
82880 }
82881
82882
82883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
82884   void * jresult ;
82885   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82886   Dali::Actor result;
82887
82888   arg1 = (Dali::Toolkit::Popup *)jarg1;
82889   {
82890     try {
82891       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
82892     } catch (std::out_of_range& e) {
82893       {
82894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82895       };
82896     } catch (std::exception& e) {
82897       {
82898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82899       };
82900     } catch (Dali::DaliException e) {
82901       {
82902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82903       };
82904     } catch (...) {
82905       {
82906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82907       };
82908     }
82909   }
82910
82911   jresult = new Dali::Actor((const Dali::Actor &)result);
82912   return jresult;
82913 }
82914
82915
82916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
82917   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82918   Dali::Actor arg2 ;
82919   Dali::Actor *argp2 ;
82920
82921   arg1 = (Dali::Toolkit::Popup *)jarg1;
82922   argp2 = (Dali::Actor *)jarg2;
82923   if (!argp2) {
82924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82925     return ;
82926   }
82927   arg2 = *argp2;
82928   {
82929     try {
82930       (arg1)->SetFooter(arg2);
82931     } catch (std::out_of_range& e) {
82932       {
82933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82934       };
82935     } catch (std::exception& e) {
82936       {
82937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82938       };
82939     } catch (Dali::DaliException e) {
82940       {
82941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82942       };
82943     } catch (...) {
82944       {
82945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82946       };
82947     }
82948   }
82949
82950 }
82951
82952
82953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
82954   void * jresult ;
82955   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82956   Dali::Actor result;
82957
82958   arg1 = (Dali::Toolkit::Popup *)jarg1;
82959   {
82960     try {
82961       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
82962     } catch (std::out_of_range& e) {
82963       {
82964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82965       };
82966     } catch (std::exception& e) {
82967       {
82968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82969       };
82970     } catch (Dali::DaliException e) {
82971       {
82972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82973       };
82974     } catch (...) {
82975       {
82976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82977       };
82978     }
82979   }
82980
82981   jresult = new Dali::Actor((const Dali::Actor &)result);
82982   return jresult;
82983 }
82984
82985
82986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
82987   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82988   Dali::Toolkit::Popup::DisplayState arg2 ;
82989
82990   arg1 = (Dali::Toolkit::Popup *)jarg1;
82991   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
82992   {
82993     try {
82994       (arg1)->SetDisplayState(arg2);
82995     } catch (std::out_of_range& e) {
82996       {
82997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82998       };
82999     } catch (std::exception& e) {
83000       {
83001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83002       };
83003     } catch (Dali::DaliException e) {
83004       {
83005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83006       };
83007     } catch (...) {
83008       {
83009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83010       };
83011     }
83012   }
83013
83014 }
83015
83016
83017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83018   int jresult ;
83019   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83020   Dali::Toolkit::Popup::DisplayState result;
83021
83022   arg1 = (Dali::Toolkit::Popup *)jarg1;
83023   {
83024     try {
83025       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83026     } catch (std::out_of_range& e) {
83027       {
83028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83029       };
83030     } catch (std::exception& e) {
83031       {
83032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83033       };
83034     } catch (Dali::DaliException e) {
83035       {
83036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83037       };
83038     } catch (...) {
83039       {
83040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83041       };
83042     }
83043   }
83044
83045   jresult = (int)result;
83046   return jresult;
83047 }
83048
83049
83050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83051   void * jresult ;
83052   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83053   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83054
83055   arg1 = (Dali::Toolkit::Popup *)jarg1;
83056   {
83057     try {
83058       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83059     } catch (std::out_of_range& e) {
83060       {
83061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83062       };
83063     } catch (std::exception& e) {
83064       {
83065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83066       };
83067     } catch (Dali::DaliException e) {
83068       {
83069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83070       };
83071     } catch (...) {
83072       {
83073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83074       };
83075     }
83076   }
83077
83078   jresult = (void *)result;
83079   return jresult;
83080 }
83081
83082
83083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83084   void * jresult ;
83085   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83086   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83087
83088   arg1 = (Dali::Toolkit::Popup *)jarg1;
83089   {
83090     try {
83091       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83092     } catch (std::out_of_range& e) {
83093       {
83094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83095       };
83096     } catch (std::exception& e) {
83097       {
83098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83099       };
83100     } catch (Dali::DaliException e) {
83101       {
83102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83103       };
83104     } catch (...) {
83105       {
83106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83107       };
83108     }
83109   }
83110
83111   jresult = (void *)result;
83112   return jresult;
83113 }
83114
83115
83116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83117   void * jresult ;
83118   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83119   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83120
83121   arg1 = (Dali::Toolkit::Popup *)jarg1;
83122   {
83123     try {
83124       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83125     } catch (std::out_of_range& e) {
83126       {
83127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83128       };
83129     } catch (std::exception& e) {
83130       {
83131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83132       };
83133     } catch (Dali::DaliException e) {
83134       {
83135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83136       };
83137     } catch (...) {
83138       {
83139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83140       };
83141     }
83142   }
83143
83144   jresult = (void *)result;
83145   return jresult;
83146 }
83147
83148
83149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83150   void * jresult ;
83151   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83152   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83153
83154   arg1 = (Dali::Toolkit::Popup *)jarg1;
83155   {
83156     try {
83157       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83158     } catch (std::out_of_range& e) {
83159       {
83160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83161       };
83162     } catch (std::exception& e) {
83163       {
83164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83165       };
83166     } catch (Dali::DaliException e) {
83167       {
83168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83169       };
83170     } catch (...) {
83171       {
83172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83173       };
83174     }
83175   }
83176
83177   jresult = (void *)result;
83178   return jresult;
83179 }
83180
83181
83182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83183   void * jresult ;
83184   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83185   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83186
83187   arg1 = (Dali::Toolkit::Popup *)jarg1;
83188   {
83189     try {
83190       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83191     } catch (std::out_of_range& e) {
83192       {
83193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83194       };
83195     } catch (std::exception& e) {
83196       {
83197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83198       };
83199     } catch (Dali::DaliException e) {
83200       {
83201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83202       };
83203     } catch (...) {
83204       {
83205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83206       };
83207     }
83208   }
83209
83210   jresult = (void *)result;
83211   return jresult;
83212 }
83213
83214
83215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83216   int jresult ;
83217   int result;
83218
83219   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83220   jresult = (int)result;
83221   return jresult;
83222 }
83223
83224
83225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83226   int jresult ;
83227   int result;
83228
83229   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83230   jresult = (int)result;
83231   return jresult;
83232 }
83233
83234
83235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83236   int jresult ;
83237   int result;
83238
83239   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83240   jresult = (int)result;
83241   return jresult;
83242 }
83243
83244
83245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83246   int jresult ;
83247   int result;
83248
83249   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83250   jresult = (int)result;
83251   return jresult;
83252 }
83253
83254
83255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83256   int jresult ;
83257   int result;
83258
83259   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83260   jresult = (int)result;
83261   return jresult;
83262 }
83263
83264
83265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83266   int jresult ;
83267   int result;
83268
83269   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83270   jresult = (int)result;
83271   return jresult;
83272 }
83273
83274
83275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83276   int jresult ;
83277   int result;
83278
83279   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83280   jresult = (int)result;
83281   return jresult;
83282 }
83283
83284
83285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83286   int jresult ;
83287   int result;
83288
83289   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83290   jresult = (int)result;
83291   return jresult;
83292 }
83293
83294
83295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83296   int jresult ;
83297   int result;
83298
83299   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83300   jresult = (int)result;
83301   return jresult;
83302 }
83303
83304
83305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83306   void * jresult ;
83307   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83308
83309   {
83310     try {
83311       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83312     } catch (std::out_of_range& e) {
83313       {
83314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83315       };
83316     } catch (std::exception& e) {
83317       {
83318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83319       };
83320     } catch (Dali::DaliException e) {
83321       {
83322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83323       };
83324     } catch (...) {
83325       {
83326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83327       };
83328     }
83329   }
83330
83331   jresult = (void *)result;
83332   return jresult;
83333 }
83334
83335
83336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83337   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83338
83339   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83340   {
83341     try {
83342       delete arg1;
83343     } catch (std::out_of_range& e) {
83344       {
83345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83346       };
83347     } catch (std::exception& e) {
83348       {
83349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83350       };
83351     } catch (Dali::DaliException e) {
83352       {
83353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83354       };
83355     } catch (...) {
83356       {
83357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83358       };
83359     }
83360   }
83361
83362 }
83363
83364
83365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83366   void * jresult ;
83367   Dali::Toolkit::ProgressBar result;
83368
83369   {
83370     try {
83371       result = Dali::Toolkit::ProgressBar::New();
83372     } catch (std::out_of_range& e) {
83373       {
83374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83375       };
83376     } catch (std::exception& e) {
83377       {
83378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83379       };
83380     } catch (Dali::DaliException e) {
83381       {
83382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83383       };
83384     } catch (...) {
83385       {
83386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83387       };
83388     }
83389   }
83390
83391   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83392   return jresult;
83393 }
83394
83395
83396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83397   void * jresult ;
83398   Dali::Toolkit::ProgressBar *result = 0 ;
83399
83400   {
83401     try {
83402       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83403     } catch (std::out_of_range& e) {
83404       {
83405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83406       };
83407     } catch (std::exception& e) {
83408       {
83409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83410       };
83411     } catch (Dali::DaliException e) {
83412       {
83413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83414       };
83415     } catch (...) {
83416       {
83417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83418       };
83419     }
83420   }
83421
83422   jresult = (void *)result;
83423   return jresult;
83424 }
83425
83426
83427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83428   void * jresult ;
83429   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83430   Dali::Toolkit::ProgressBar *result = 0 ;
83431
83432   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83433   if (!arg1) {
83434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83435     return 0;
83436   }
83437   {
83438     try {
83439       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83440     } catch (std::out_of_range& e) {
83441       {
83442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83443       };
83444     } catch (std::exception& e) {
83445       {
83446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83447       };
83448     } catch (Dali::DaliException e) {
83449       {
83450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83451       };
83452     } catch (...) {
83453       {
83454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83455       };
83456     }
83457   }
83458
83459   jresult = (void *)result;
83460   return jresult;
83461 }
83462
83463
83464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83465   void * jresult ;
83466   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83467   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83468   Dali::Toolkit::ProgressBar *result = 0 ;
83469
83470   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83471   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83472   if (!arg2) {
83473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83474     return 0;
83475   }
83476   {
83477     try {
83478       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83479     } catch (std::out_of_range& e) {
83480       {
83481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83482       };
83483     } catch (std::exception& e) {
83484       {
83485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83486       };
83487     } catch (Dali::DaliException e) {
83488       {
83489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83490       };
83491     } catch (...) {
83492       {
83493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83494       };
83495     }
83496   }
83497
83498   jresult = (void *)result;
83499   return jresult;
83500 }
83501
83502
83503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83504   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83505
83506   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83507   {
83508     try {
83509       delete arg1;
83510     } catch (std::out_of_range& e) {
83511       {
83512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83513       };
83514     } catch (std::exception& e) {
83515       {
83516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83517       };
83518     } catch (Dali::DaliException e) {
83519       {
83520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83521       };
83522     } catch (...) {
83523       {
83524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83525       };
83526     }
83527   }
83528
83529 }
83530
83531
83532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83533   void * jresult ;
83534   Dali::BaseHandle arg1 ;
83535   Dali::BaseHandle *argp1 ;
83536   Dali::Toolkit::ProgressBar result;
83537
83538   argp1 = (Dali::BaseHandle *)jarg1;
83539   if (!argp1) {
83540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83541     return 0;
83542   }
83543   arg1 = *argp1;
83544   {
83545     try {
83546       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83547     } catch (std::out_of_range& e) {
83548       {
83549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83550       };
83551     } catch (std::exception& e) {
83552       {
83553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83554       };
83555     } catch (Dali::DaliException e) {
83556       {
83557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83558       };
83559     } catch (...) {
83560       {
83561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83562       };
83563     }
83564   }
83565
83566   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83567   return jresult;
83568 }
83569
83570
83571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83572   void * jresult ;
83573   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83574   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83575
83576   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83577   {
83578     try {
83579       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83580     } catch (std::out_of_range& e) {
83581       {
83582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83583       };
83584     } catch (std::exception& e) {
83585       {
83586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83587       };
83588     } catch (Dali::DaliException e) {
83589       {
83590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83591       };
83592     } catch (...) {
83593       {
83594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83595       };
83596     }
83597   }
83598
83599   jresult = (void *)result;
83600   return jresult;
83601 }
83602
83603
83604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83605   void * jresult ;
83606   Dali::Toolkit::GaussianBlurView *result = 0 ;
83607
83608   {
83609     try {
83610       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83611     } catch (std::out_of_range& e) {
83612       {
83613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83614       };
83615     } catch (std::exception& e) {
83616       {
83617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83618       };
83619     } catch (Dali::DaliException e) {
83620       {
83621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83622       };
83623     } catch (...) {
83624       {
83625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83626       };
83627     }
83628   }
83629
83630   jresult = (void *)result;
83631   return jresult;
83632 }
83633
83634
83635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83636   void * jresult ;
83637   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83638   Dali::Toolkit::GaussianBlurView *result = 0 ;
83639
83640   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83641   if (!arg1) {
83642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83643     return 0;
83644   }
83645   {
83646     try {
83647       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83648     } catch (std::out_of_range& e) {
83649       {
83650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83651       };
83652     } catch (std::exception& e) {
83653       {
83654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83655       };
83656     } catch (Dali::DaliException e) {
83657       {
83658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83659       };
83660     } catch (...) {
83661       {
83662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83663       };
83664     }
83665   }
83666
83667   jresult = (void *)result;
83668   return jresult;
83669 }
83670
83671
83672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83673   void * jresult ;
83674   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83675   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83676   Dali::Toolkit::GaussianBlurView *result = 0 ;
83677
83678   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83679   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83680   if (!arg2) {
83681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83682     return 0;
83683   }
83684   {
83685     try {
83686       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
83687     } catch (std::out_of_range& e) {
83688       {
83689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83690       };
83691     } catch (std::exception& e) {
83692       {
83693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83694       };
83695     } catch (Dali::DaliException e) {
83696       {
83697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83698       };
83699     } catch (...) {
83700       {
83701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83702       };
83703     }
83704   }
83705
83706   jresult = (void *)result;
83707   return jresult;
83708 }
83709
83710
83711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
83712   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83713
83714   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83715   {
83716     try {
83717       delete arg1;
83718     } catch (std::out_of_range& e) {
83719       {
83720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83721       };
83722     } catch (std::exception& e) {
83723       {
83724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83725       };
83726     } catch (Dali::DaliException e) {
83727       {
83728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83729       };
83730     } catch (...) {
83731       {
83732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83733       };
83734     }
83735   }
83736
83737 }
83738
83739
83740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
83741   void * jresult ;
83742   Dali::BaseHandle arg1 ;
83743   Dali::BaseHandle *argp1 ;
83744   Dali::Toolkit::GaussianBlurView result;
83745
83746   argp1 = (Dali::BaseHandle *)jarg1;
83747   if (!argp1) {
83748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83749     return 0;
83750   }
83751   arg1 = *argp1;
83752   {
83753     try {
83754       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83755     } catch (std::out_of_range& e) {
83756       {
83757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83758       };
83759     } catch (std::exception& e) {
83760       {
83761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83762       };
83763     } catch (Dali::DaliException e) {
83764       {
83765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83766       };
83767     } catch (...) {
83768       {
83769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83770       };
83771     }
83772   }
83773
83774   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83775   return jresult;
83776 }
83777
83778
83779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
83780   void * jresult ;
83781   Dali::Toolkit::GaussianBlurView result;
83782
83783   {
83784     try {
83785       result = Dali::Toolkit::GaussianBlurView::New();
83786     } catch (std::out_of_range& e) {
83787       {
83788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83789       };
83790     } catch (std::exception& e) {
83791       {
83792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83793       };
83794     } catch (Dali::DaliException e) {
83795       {
83796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83797       };
83798     } catch (...) {
83799       {
83800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83801       };
83802     }
83803   }
83804
83805   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83806   return jresult;
83807 }
83808
83809
83810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
83811   void * jresult ;
83812   unsigned int arg1 ;
83813   float arg2 ;
83814   Dali::Pixel::Format arg3 ;
83815   float arg4 ;
83816   float arg5 ;
83817   bool arg6 ;
83818   Dali::Toolkit::GaussianBlurView result;
83819
83820   arg1 = (unsigned int)jarg1;
83821   arg2 = (float)jarg2;
83822   arg3 = (Dali::Pixel::Format)jarg3;
83823   arg4 = (float)jarg4;
83824   arg5 = (float)jarg5;
83825   arg6 = jarg6 ? true : false;
83826   {
83827     try {
83828       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
83829     } catch (std::out_of_range& e) {
83830       {
83831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83832       };
83833     } catch (std::exception& e) {
83834       {
83835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83836       };
83837     } catch (Dali::DaliException e) {
83838       {
83839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83840       };
83841     } catch (...) {
83842       {
83843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83844       };
83845     }
83846   }
83847
83848   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83849   return jresult;
83850 }
83851
83852
83853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
83854   void * jresult ;
83855   unsigned int arg1 ;
83856   float arg2 ;
83857   Dali::Pixel::Format arg3 ;
83858   float arg4 ;
83859   float arg5 ;
83860   Dali::Toolkit::GaussianBlurView result;
83861
83862   arg1 = (unsigned int)jarg1;
83863   arg2 = (float)jarg2;
83864   arg3 = (Dali::Pixel::Format)jarg3;
83865   arg4 = (float)jarg4;
83866   arg5 = (float)jarg5;
83867   {
83868     try {
83869       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
83870     } catch (std::out_of_range& e) {
83871       {
83872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83873       };
83874     } catch (std::exception& e) {
83875       {
83876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83877       };
83878     } catch (Dali::DaliException e) {
83879       {
83880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83881       };
83882     } catch (...) {
83883       {
83884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83885       };
83886     }
83887   }
83888
83889   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83890   return jresult;
83891 }
83892
83893
83894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
83895   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83896   Dali::Actor arg2 ;
83897   Dali::Actor *argp2 ;
83898
83899   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83900   argp2 = (Dali::Actor *)jarg2;
83901   if (!argp2) {
83902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83903     return ;
83904   }
83905   arg2 = *argp2;
83906   {
83907     try {
83908       (arg1)->Add(arg2);
83909     } catch (std::out_of_range& e) {
83910       {
83911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83912       };
83913     } catch (std::exception& e) {
83914       {
83915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83916       };
83917     } catch (Dali::DaliException e) {
83918       {
83919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83920       };
83921     } catch (...) {
83922       {
83923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83924       };
83925     }
83926   }
83927
83928 }
83929
83930
83931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
83932   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83933   Dali::Actor arg2 ;
83934   Dali::Actor *argp2 ;
83935
83936   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83937   argp2 = (Dali::Actor *)jarg2;
83938   if (!argp2) {
83939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83940     return ;
83941   }
83942   arg2 = *argp2;
83943   {
83944     try {
83945       (arg1)->Remove(arg2);
83946     } catch (std::out_of_range& e) {
83947       {
83948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83949       };
83950     } catch (std::exception& e) {
83951       {
83952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83953       };
83954     } catch (Dali::DaliException e) {
83955       {
83956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83957       };
83958     } catch (...) {
83959       {
83960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83961       };
83962     }
83963   }
83964
83965 }
83966
83967
83968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
83969   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83970
83971   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83972   {
83973     try {
83974       (arg1)->Activate();
83975     } catch (std::out_of_range& e) {
83976       {
83977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83978       };
83979     } catch (std::exception& e) {
83980       {
83981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83982       };
83983     } catch (Dali::DaliException e) {
83984       {
83985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83986       };
83987     } catch (...) {
83988       {
83989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83990       };
83991     }
83992   }
83993
83994 }
83995
83996
83997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
83998   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83999
84000   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84001   {
84002     try {
84003       (arg1)->ActivateOnce();
84004     } catch (std::out_of_range& e) {
84005       {
84006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84007       };
84008     } catch (std::exception& e) {
84009       {
84010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84011       };
84012     } catch (Dali::DaliException e) {
84013       {
84014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84015       };
84016     } catch (...) {
84017       {
84018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84019       };
84020     }
84021   }
84022
84023 }
84024
84025
84026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84027   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84028
84029   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84030   {
84031     try {
84032       (arg1)->Deactivate();
84033     } catch (std::out_of_range& e) {
84034       {
84035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84036       };
84037     } catch (std::exception& e) {
84038       {
84039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84040       };
84041     } catch (Dali::DaliException e) {
84042       {
84043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84044       };
84045     } catch (...) {
84046       {
84047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84048       };
84049     }
84050   }
84051
84052 }
84053
84054
84055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84056   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84057   Dali::Texture arg2 ;
84058   Dali::FrameBuffer arg3 ;
84059   Dali::Texture *argp2 ;
84060   Dali::FrameBuffer *argp3 ;
84061
84062   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84063   argp2 = (Dali::Texture *)jarg2;
84064   if (!argp2) {
84065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
84066     return ;
84067   }
84068   arg2 = *argp2;
84069   argp3 = (Dali::FrameBuffer *)jarg3;
84070   if (!argp3) {
84071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
84072     return ;
84073   }
84074   arg3 = *argp3;
84075   {
84076     try {
84077       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
84078     } catch (std::out_of_range& e) {
84079       {
84080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84081       };
84082     } catch (std::exception& e) {
84083       {
84084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84085       };
84086     } catch (Dali::DaliException e) {
84087       {
84088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84089       };
84090     } catch (...) {
84091       {
84092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84093       };
84094     }
84095   }
84096
84097 }
84098
84099
84100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84101   int jresult ;
84102   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84103   Dali::Property::Index result;
84104
84105   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84106   {
84107     try {
84108       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84109     } catch (std::out_of_range& e) {
84110       {
84111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84112       };
84113     } catch (std::exception& e) {
84114       {
84115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84116       };
84117     } catch (Dali::DaliException e) {
84118       {
84119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84120       };
84121     } catch (...) {
84122       {
84123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84124       };
84125     }
84126   }
84127
84128   jresult = result;
84129   return jresult;
84130 }
84131
84132
84133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84134   void * jresult ;
84135   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84136   Dali::FrameBuffer result;
84137
84138   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84139   {
84140     try {
84141       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84142     } catch (std::out_of_range& e) {
84143       {
84144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84145       };
84146     } catch (std::exception& e) {
84147       {
84148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84149       };
84150     } catch (Dali::DaliException e) {
84151       {
84152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84153       };
84154     } catch (...) {
84155       {
84156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84157       };
84158     }
84159   }
84160
84161   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
84162   return jresult;
84163 }
84164
84165
84166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84167   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84168   Dali::Vector4 *arg2 = 0 ;
84169
84170   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84171   arg2 = (Dali::Vector4 *)jarg2;
84172   if (!arg2) {
84173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84174     return ;
84175   }
84176   {
84177     try {
84178       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84179     } catch (std::out_of_range& e) {
84180       {
84181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84182       };
84183     } catch (std::exception& e) {
84184       {
84185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84186       };
84187     } catch (Dali::DaliException e) {
84188       {
84189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84190       };
84191     } catch (...) {
84192       {
84193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84194       };
84195     }
84196   }
84197
84198 }
84199
84200
84201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84202   void * jresult ;
84203   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84204   Dali::Vector4 result;
84205
84206   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84207   {
84208     try {
84209       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84210     } catch (std::out_of_range& e) {
84211       {
84212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84213       };
84214     } catch (std::exception& e) {
84215       {
84216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84217       };
84218     } catch (Dali::DaliException e) {
84219       {
84220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84221       };
84222     } catch (...) {
84223       {
84224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84225       };
84226     }
84227   }
84228
84229   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84230   return jresult;
84231 }
84232
84233
84234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84235   void * jresult ;
84236   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84237   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84238
84239   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84240   {
84241     try {
84242       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84243     } catch (std::out_of_range& e) {
84244       {
84245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84246       };
84247     } catch (std::exception& e) {
84248       {
84249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84250       };
84251     } catch (Dali::DaliException e) {
84252       {
84253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84254       };
84255     } catch (...) {
84256       {
84257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84258       };
84259     }
84260   }
84261
84262   jresult = (void *)result;
84263   return jresult;
84264 }
84265
84266
84267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84268   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84269
84270   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84271   {
84272     try {
84273       delete arg1;
84274     } catch (std::out_of_range& e) {
84275       {
84276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84277       };
84278     } catch (std::exception& e) {
84279       {
84280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84281       };
84282     } catch (Dali::DaliException e) {
84283       {
84284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84285       };
84286     } catch (...) {
84287       {
84288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84289       };
84290     }
84291   }
84292
84293 }
84294
84295
84296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84297   unsigned int jresult ;
84298   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84299   unsigned int result;
84300
84301   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84302   {
84303     try {
84304       result = (unsigned int)(arg1)->GetNumberOfPages();
84305     } catch (std::out_of_range& e) {
84306       {
84307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84308       };
84309     } catch (std::exception& e) {
84310       {
84311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84312       };
84313     } catch (Dali::DaliException e) {
84314       {
84315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84316       };
84317     } catch (...) {
84318       {
84319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84320       };
84321     }
84322   }
84323
84324   jresult = result;
84325   return jresult;
84326 }
84327
84328
84329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84330   void * jresult ;
84331   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84332   unsigned int arg2 ;
84333   Dali::Texture result;
84334
84335   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84336   arg2 = (unsigned int)jarg2;
84337   {
84338     try {
84339       result = (arg1)->NewPage(arg2);
84340     } catch (std::out_of_range& e) {
84341       {
84342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84343       };
84344     } catch (std::exception& e) {
84345       {
84346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84347       };
84348     } catch (Dali::DaliException e) {
84349       {
84350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84351       };
84352     } catch (...) {
84353       {
84354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84355       };
84356     }
84357   }
84358
84359   jresult = new Dali::Texture((const Dali::Texture &)result);
84360   return jresult;
84361 }
84362
84363
84364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
84365   int jresult ;
84366   int result;
84367
84368   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
84369   jresult = (int)result;
84370   return jresult;
84371 }
84372
84373
84374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84375   int jresult ;
84376   int result;
84377
84378   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84379   jresult = (int)result;
84380   return jresult;
84381 }
84382
84383
84384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84385   int jresult ;
84386   int result;
84387
84388   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84389   jresult = (int)result;
84390   return jresult;
84391 }
84392
84393
84394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84395   void * jresult ;
84396   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84397
84398   {
84399     try {
84400       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84401     } catch (std::out_of_range& e) {
84402       {
84403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84404       };
84405     } catch (std::exception& e) {
84406       {
84407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84408       };
84409     } catch (Dali::DaliException e) {
84410       {
84411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84412       };
84413     } catch (...) {
84414       {
84415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84416       };
84417     }
84418   }
84419
84420   jresult = (void *)result;
84421   return jresult;
84422 }
84423
84424
84425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84426   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84427
84428   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84429   {
84430     try {
84431       delete arg1;
84432     } catch (std::out_of_range& e) {
84433       {
84434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84435       };
84436     } catch (std::exception& e) {
84437       {
84438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84439       };
84440     } catch (Dali::DaliException e) {
84441       {
84442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84443       };
84444     } catch (...) {
84445       {
84446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84447       };
84448     }
84449   }
84450
84451 }
84452
84453
84454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84455   void * jresult ;
84456   Dali::Toolkit::PageTurnView *result = 0 ;
84457
84458   {
84459     try {
84460       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84461     } catch (std::out_of_range& e) {
84462       {
84463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84464       };
84465     } catch (std::exception& e) {
84466       {
84467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84468       };
84469     } catch (Dali::DaliException e) {
84470       {
84471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84472       };
84473     } catch (...) {
84474       {
84475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84476       };
84477     }
84478   }
84479
84480   jresult = (void *)result;
84481   return jresult;
84482 }
84483
84484
84485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84486   void * jresult ;
84487   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84488   Dali::Toolkit::PageTurnView *result = 0 ;
84489
84490   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84491   if (!arg1) {
84492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84493     return 0;
84494   }
84495   {
84496     try {
84497       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84498     } catch (std::out_of_range& e) {
84499       {
84500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84501       };
84502     } catch (std::exception& e) {
84503       {
84504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84505       };
84506     } catch (Dali::DaliException e) {
84507       {
84508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84509       };
84510     } catch (...) {
84511       {
84512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84513       };
84514     }
84515   }
84516
84517   jresult = (void *)result;
84518   return jresult;
84519 }
84520
84521
84522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84523   void * jresult ;
84524   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84525   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84526   Dali::Toolkit::PageTurnView *result = 0 ;
84527
84528   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84529   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84530   if (!arg2) {
84531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84532     return 0;
84533   }
84534   {
84535     try {
84536       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84537     } catch (std::out_of_range& e) {
84538       {
84539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84540       };
84541     } catch (std::exception& e) {
84542       {
84543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84544       };
84545     } catch (Dali::DaliException e) {
84546       {
84547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84548       };
84549     } catch (...) {
84550       {
84551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84552       };
84553     }
84554   }
84555
84556   jresult = (void *)result;
84557   return jresult;
84558 }
84559
84560
84561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84562   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84563
84564   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84565   {
84566     try {
84567       delete arg1;
84568     } catch (std::out_of_range& e) {
84569       {
84570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84571       };
84572     } catch (std::exception& e) {
84573       {
84574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84575       };
84576     } catch (Dali::DaliException e) {
84577       {
84578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84579       };
84580     } catch (...) {
84581       {
84582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84583       };
84584     }
84585   }
84586
84587 }
84588
84589
84590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84591   void * jresult ;
84592   Dali::BaseHandle arg1 ;
84593   Dali::BaseHandle *argp1 ;
84594   Dali::Toolkit::PageTurnView result;
84595
84596   argp1 = (Dali::BaseHandle *)jarg1;
84597   if (!argp1) {
84598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84599     return 0;
84600   }
84601   arg1 = *argp1;
84602   {
84603     try {
84604       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84605     } catch (std::out_of_range& e) {
84606       {
84607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84608       };
84609     } catch (std::exception& e) {
84610       {
84611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84612       };
84613     } catch (Dali::DaliException e) {
84614       {
84615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84616       };
84617     } catch (...) {
84618       {
84619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84620       };
84621     }
84622   }
84623
84624   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84625   return jresult;
84626 }
84627
84628
84629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84630   void * jresult ;
84631   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84632   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84633
84634   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84635   {
84636     try {
84637       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84638     } catch (std::out_of_range& e) {
84639       {
84640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84641       };
84642     } catch (std::exception& e) {
84643       {
84644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84645       };
84646     } catch (Dali::DaliException e) {
84647       {
84648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84649       };
84650     } catch (...) {
84651       {
84652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84653       };
84654     }
84655   }
84656
84657   jresult = (void *)result;
84658   return jresult;
84659 }
84660
84661
84662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84663   void * jresult ;
84664   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84665   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84666
84667   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84668   {
84669     try {
84670       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84671     } catch (std::out_of_range& e) {
84672       {
84673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84674       };
84675     } catch (std::exception& e) {
84676       {
84677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84678       };
84679     } catch (Dali::DaliException e) {
84680       {
84681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84682       };
84683     } catch (...) {
84684       {
84685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84686       };
84687     }
84688   }
84689
84690   jresult = (void *)result;
84691   return jresult;
84692 }
84693
84694
84695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
84696   void * jresult ;
84697   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84698   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84699
84700   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84701   {
84702     try {
84703       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84704     } catch (std::out_of_range& e) {
84705       {
84706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84707       };
84708     } catch (std::exception& e) {
84709       {
84710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84711       };
84712     } catch (Dali::DaliException e) {
84713       {
84714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84715       };
84716     } catch (...) {
84717       {
84718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84719       };
84720     }
84721   }
84722
84723   jresult = (void *)result;
84724   return jresult;
84725 }
84726
84727
84728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84729   void * jresult ;
84730   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84731   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84732
84733   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84734   {
84735     try {
84736       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84737     } catch (std::out_of_range& e) {
84738       {
84739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84740       };
84741     } catch (std::exception& e) {
84742       {
84743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84744       };
84745     } catch (Dali::DaliException e) {
84746       {
84747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84748       };
84749     } catch (...) {
84750       {
84751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84752       };
84753     }
84754   }
84755
84756   jresult = (void *)result;
84757   return jresult;
84758 }
84759
84760
84761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
84762   void * jresult ;
84763   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84764
84765   {
84766     try {
84767       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84768     } catch (std::out_of_range& e) {
84769       {
84770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84771       };
84772     } catch (std::exception& e) {
84773       {
84774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84775       };
84776     } catch (Dali::DaliException e) {
84777       {
84778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84779       };
84780     } catch (...) {
84781       {
84782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84783       };
84784     }
84785   }
84786
84787   jresult = (void *)result;
84788   return jresult;
84789 }
84790
84791
84792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84793   void * jresult ;
84794   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84795   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84796
84797   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84798   if (!arg1) {
84799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84800     return 0;
84801   }
84802   {
84803     try {
84804       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
84805     } catch (std::out_of_range& e) {
84806       {
84807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84808       };
84809     } catch (std::exception& e) {
84810       {
84811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84812       };
84813     } catch (Dali::DaliException e) {
84814       {
84815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84816       };
84817     } catch (...) {
84818       {
84819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84820       };
84821     }
84822   }
84823
84824   jresult = (void *)result;
84825   return jresult;
84826 }
84827
84828
84829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
84830   void * jresult ;
84831   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84832   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
84833   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84834
84835   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84836   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
84837   if (!arg2) {
84838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84839     return 0;
84840   }
84841   {
84842     try {
84843       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
84844     } catch (std::out_of_range& e) {
84845       {
84846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84847       };
84848     } catch (std::exception& e) {
84849       {
84850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84851       };
84852     } catch (Dali::DaliException e) {
84853       {
84854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84855       };
84856     } catch (...) {
84857       {
84858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84859       };
84860     }
84861   }
84862
84863   jresult = (void *)result;
84864   return jresult;
84865 }
84866
84867
84868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
84869   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84870
84871   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84872   {
84873     try {
84874       delete arg1;
84875     } catch (std::out_of_range& e) {
84876       {
84877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84878       };
84879     } catch (std::exception& e) {
84880       {
84881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84882       };
84883     } catch (Dali::DaliException e) {
84884       {
84885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84886       };
84887     } catch (...) {
84888       {
84889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84890       };
84891     }
84892   }
84893
84894 }
84895
84896
84897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
84898   void * jresult ;
84899   Dali::Toolkit::PageFactory *arg1 = 0 ;
84900   Dali::Vector2 *arg2 = 0 ;
84901   Dali::Toolkit::PageTurnLandscapeView result;
84902
84903   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84904   if (!arg1) {
84905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84906     return 0;
84907   }
84908   arg2 = (Dali::Vector2 *)jarg2;
84909   if (!arg2) {
84910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84911     return 0;
84912   }
84913   {
84914     try {
84915       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
84916     } catch (std::out_of_range& e) {
84917       {
84918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84919       };
84920     } catch (std::exception& e) {
84921       {
84922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84923       };
84924     } catch (Dali::DaliException e) {
84925       {
84926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84927       };
84928     } catch (...) {
84929       {
84930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84931       };
84932     }
84933   }
84934
84935   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84936   return jresult;
84937 }
84938
84939
84940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
84941   void * jresult ;
84942   Dali::BaseHandle arg1 ;
84943   Dali::BaseHandle *argp1 ;
84944   Dali::Toolkit::PageTurnLandscapeView result;
84945
84946   argp1 = (Dali::BaseHandle *)jarg1;
84947   if (!argp1) {
84948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84949     return 0;
84950   }
84951   arg1 = *argp1;
84952   {
84953     try {
84954       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
84955     } catch (std::out_of_range& e) {
84956       {
84957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84958       };
84959     } catch (std::exception& e) {
84960       {
84961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84962       };
84963     } catch (Dali::DaliException e) {
84964       {
84965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84966       };
84967     } catch (...) {
84968       {
84969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84970       };
84971     }
84972   }
84973
84974   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84975   return jresult;
84976 }
84977
84978
84979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
84980   void * jresult ;
84981   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84982
84983   {
84984     try {
84985       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
84986     } catch (std::out_of_range& e) {
84987       {
84988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84989       };
84990     } catch (std::exception& e) {
84991       {
84992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84993       };
84994     } catch (Dali::DaliException e) {
84995       {
84996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84997       };
84998     } catch (...) {
84999       {
85000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85001       };
85002     }
85003   }
85004
85005   jresult = (void *)result;
85006   return jresult;
85007 }
85008
85009
85010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
85011   void * jresult ;
85012   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
85013   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85014
85015   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85016   if (!arg1) {
85017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85018     return 0;
85019   }
85020   {
85021     try {
85022       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
85023     } catch (std::out_of_range& e) {
85024       {
85025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85026       };
85027     } catch (std::exception& e) {
85028       {
85029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85030       };
85031     } catch (Dali::DaliException e) {
85032       {
85033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85034       };
85035     } catch (...) {
85036       {
85037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85038       };
85039     }
85040   }
85041
85042   jresult = (void *)result;
85043   return jresult;
85044 }
85045
85046
85047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
85048   void * jresult ;
85049   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85050   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
85051   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85052
85053   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85054   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
85055   if (!arg2) {
85056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85057     return 0;
85058   }
85059   {
85060     try {
85061       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
85062     } catch (std::out_of_range& e) {
85063       {
85064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85065       };
85066     } catch (std::exception& e) {
85067       {
85068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85069       };
85070     } catch (Dali::DaliException e) {
85071       {
85072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85073       };
85074     } catch (...) {
85075       {
85076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85077       };
85078     }
85079   }
85080
85081   jresult = (void *)result;
85082   return jresult;
85083 }
85084
85085
85086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
85087   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85088
85089   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85090   {
85091     try {
85092       delete arg1;
85093     } catch (std::out_of_range& e) {
85094       {
85095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85096       };
85097     } catch (std::exception& e) {
85098       {
85099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85100       };
85101     } catch (Dali::DaliException e) {
85102       {
85103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85104       };
85105     } catch (...) {
85106       {
85107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85108       };
85109     }
85110   }
85111
85112 }
85113
85114
85115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
85116   void * jresult ;
85117   Dali::Toolkit::PageFactory *arg1 = 0 ;
85118   Dali::Vector2 *arg2 = 0 ;
85119   Dali::Toolkit::PageTurnPortraitView result;
85120
85121   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85122   if (!arg1) {
85123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85124     return 0;
85125   }
85126   arg2 = (Dali::Vector2 *)jarg2;
85127   if (!arg2) {
85128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85129     return 0;
85130   }
85131   {
85132     try {
85133       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85134     } catch (std::out_of_range& e) {
85135       {
85136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85137       };
85138     } catch (std::exception& e) {
85139       {
85140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85141       };
85142     } catch (Dali::DaliException e) {
85143       {
85144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85145       };
85146     } catch (...) {
85147       {
85148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85149       };
85150     }
85151   }
85152
85153   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85154   return jresult;
85155 }
85156
85157
85158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85159   void * jresult ;
85160   Dali::BaseHandle arg1 ;
85161   Dali::BaseHandle *argp1 ;
85162   Dali::Toolkit::PageTurnPortraitView result;
85163
85164   argp1 = (Dali::BaseHandle *)jarg1;
85165   if (!argp1) {
85166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85167     return 0;
85168   }
85169   arg1 = *argp1;
85170   {
85171     try {
85172       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85173     } catch (std::out_of_range& e) {
85174       {
85175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85176       };
85177     } catch (std::exception& e) {
85178       {
85179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85180       };
85181     } catch (Dali::DaliException e) {
85182       {
85183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85184       };
85185     } catch (...) {
85186       {
85187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85188       };
85189     }
85190   }
85191
85192   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85193   return jresult;
85194 }
85195
85196
85197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85198   int jresult ;
85199   int result;
85200
85201   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85202   jresult = (int)result;
85203   return jresult;
85204 }
85205
85206
85207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85208   int jresult ;
85209   int result;
85210
85211   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85212   jresult = (int)result;
85213   return jresult;
85214 }
85215
85216
85217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85218   int jresult ;
85219   int result;
85220
85221   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85222   jresult = (int)result;
85223   return jresult;
85224 }
85225
85226
85227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85228   void * jresult ;
85229   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85230
85231   {
85232     try {
85233       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85234     } catch (std::out_of_range& e) {
85235       {
85236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85237       };
85238     } catch (std::exception& e) {
85239       {
85240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85241       };
85242     } catch (Dali::DaliException e) {
85243       {
85244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85245       };
85246     } catch (...) {
85247       {
85248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85249       };
85250     }
85251   }
85252
85253   jresult = (void *)result;
85254   return jresult;
85255 }
85256
85257
85258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85259   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85260
85261   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85262   {
85263     try {
85264       delete arg1;
85265     } catch (std::out_of_range& e) {
85266       {
85267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85268       };
85269     } catch (std::exception& e) {
85270       {
85271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85272       };
85273     } catch (Dali::DaliException e) {
85274       {
85275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85276       };
85277     } catch (...) {
85278       {
85279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85280       };
85281     }
85282   }
85283
85284 }
85285
85286
85287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85288   void * jresult ;
85289   Dali::Toolkit::ToggleButton *result = 0 ;
85290
85291   {
85292     try {
85293       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85294     } catch (std::out_of_range& e) {
85295       {
85296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85297       };
85298     } catch (std::exception& e) {
85299       {
85300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85301       };
85302     } catch (Dali::DaliException e) {
85303       {
85304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85305       };
85306     } catch (...) {
85307       {
85308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85309       };
85310     }
85311   }
85312
85313   jresult = (void *)result;
85314   return jresult;
85315 }
85316
85317
85318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85319   void * jresult ;
85320   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85321   Dali::Toolkit::ToggleButton *result = 0 ;
85322
85323   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85324   if (!arg1) {
85325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85326     return 0;
85327   }
85328   {
85329     try {
85330       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85331     } catch (std::out_of_range& e) {
85332       {
85333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85334       };
85335     } catch (std::exception& e) {
85336       {
85337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85338       };
85339     } catch (Dali::DaliException e) {
85340       {
85341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85342       };
85343     } catch (...) {
85344       {
85345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85346       };
85347     }
85348   }
85349
85350   jresult = (void *)result;
85351   return jresult;
85352 }
85353
85354
85355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85356   void * jresult ;
85357   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85358   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85359   Dali::Toolkit::ToggleButton *result = 0 ;
85360
85361   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85362   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85363   if (!arg2) {
85364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85365     return 0;
85366   }
85367   {
85368     try {
85369       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85370     } catch (std::out_of_range& e) {
85371       {
85372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85373       };
85374     } catch (std::exception& e) {
85375       {
85376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85377       };
85378     } catch (Dali::DaliException e) {
85379       {
85380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85381       };
85382     } catch (...) {
85383       {
85384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85385       };
85386     }
85387   }
85388
85389   jresult = (void *)result;
85390   return jresult;
85391 }
85392
85393
85394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85395   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85396
85397   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85398   {
85399     try {
85400       delete arg1;
85401     } catch (std::out_of_range& e) {
85402       {
85403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85404       };
85405     } catch (std::exception& e) {
85406       {
85407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85408       };
85409     } catch (Dali::DaliException e) {
85410       {
85411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85412       };
85413     } catch (...) {
85414       {
85415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85416       };
85417     }
85418   }
85419
85420 }
85421
85422
85423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85424   void * jresult ;
85425   Dali::Toolkit::ToggleButton result;
85426
85427   {
85428     try {
85429       result = Dali::Toolkit::ToggleButton::New();
85430     } catch (std::out_of_range& e) {
85431       {
85432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85433       };
85434     } catch (std::exception& e) {
85435       {
85436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85437       };
85438     } catch (Dali::DaliException e) {
85439       {
85440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85441       };
85442     } catch (...) {
85443       {
85444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85445       };
85446     }
85447   }
85448
85449   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85450   return jresult;
85451 }
85452
85453
85454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85455   void * jresult ;
85456   Dali::BaseHandle arg1 ;
85457   Dali::BaseHandle *argp1 ;
85458   Dali::Toolkit::ToggleButton result;
85459
85460   argp1 = (Dali::BaseHandle *)jarg1;
85461   if (!argp1) {
85462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85463     return 0;
85464   }
85465   arg1 = *argp1;
85466   {
85467     try {
85468       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
85469     } catch (std::out_of_range& e) {
85470       {
85471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85472       };
85473     } catch (std::exception& e) {
85474       {
85475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85476       };
85477     } catch (Dali::DaliException e) {
85478       {
85479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85480       };
85481     } catch (...) {
85482       {
85483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85484       };
85485     }
85486   }
85487
85488   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85489   return jresult;
85490 }
85491
85492
85493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85494   void * jresult ;
85495   Dali::Toolkit::Visual::Base *result = 0 ;
85496
85497   {
85498     try {
85499       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85500     } catch (std::out_of_range& e) {
85501       {
85502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85503       };
85504     } catch (std::exception& e) {
85505       {
85506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85507       };
85508     } catch (Dali::DaliException e) {
85509       {
85510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85511       };
85512     } catch (...) {
85513       {
85514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85515       };
85516     }
85517   }
85518
85519   jresult = (void *)result;
85520   return jresult;
85521 }
85522
85523
85524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85525   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85526
85527   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85528   {
85529     try {
85530       delete arg1;
85531     } catch (std::out_of_range& e) {
85532       {
85533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85534       };
85535     } catch (std::exception& e) {
85536       {
85537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85538       };
85539     } catch (Dali::DaliException e) {
85540       {
85541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85542       };
85543     } catch (...) {
85544       {
85545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85546       };
85547     }
85548   }
85549
85550 }
85551
85552
85553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85554   void * jresult ;
85555   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85556   Dali::Toolkit::Visual::Base *result = 0 ;
85557
85558   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85559   if (!arg1) {
85560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85561     return 0;
85562   }
85563   {
85564     try {
85565       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85566     } catch (std::out_of_range& e) {
85567       {
85568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85569       };
85570     } catch (std::exception& e) {
85571       {
85572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85573       };
85574     } catch (Dali::DaliException e) {
85575       {
85576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85577       };
85578     } catch (...) {
85579       {
85580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85581       };
85582     }
85583   }
85584
85585   jresult = (void *)result;
85586   return jresult;
85587 }
85588
85589
85590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85591   void * jresult ;
85592   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85593   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85594   Dali::Toolkit::Visual::Base *result = 0 ;
85595
85596   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85597   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85598   if (!arg2) {
85599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85600     return 0;
85601   }
85602   {
85603     try {
85604       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
85605     } catch (std::out_of_range& e) {
85606       {
85607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85608       };
85609     } catch (std::exception& e) {
85610       {
85611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85612       };
85613     } catch (Dali::DaliException e) {
85614       {
85615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85616       };
85617     } catch (...) {
85618       {
85619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85620       };
85621     }
85622   }
85623
85624   jresult = (void *)result;
85625   return jresult;
85626 }
85627
85628
85629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85630   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85631   std::string *arg2 = 0 ;
85632
85633   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85634   if (!jarg2) {
85635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85636     return ;
85637   }
85638   std::string arg2_str(jarg2);
85639   arg2 = &arg2_str;
85640   {
85641     try {
85642       (arg1)->SetName((std::string const &)*arg2);
85643     } catch (std::out_of_range& e) {
85644       {
85645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85646       };
85647     } catch (std::exception& e) {
85648       {
85649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85650       };
85651     } catch (Dali::DaliException e) {
85652       {
85653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85654       };
85655     } catch (...) {
85656       {
85657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85658       };
85659     }
85660   }
85661
85662
85663   //argout typemap for const std::string&
85664
85665 }
85666
85667
85668 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
85669   char * jresult ;
85670   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85671   std::string *result = 0 ;
85672
85673   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85674   {
85675     try {
85676       result = (std::string *) &(arg1)->GetName();
85677     } catch (std::out_of_range& e) {
85678       {
85679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85680       };
85681     } catch (std::exception& e) {
85682       {
85683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85684       };
85685     } catch (Dali::DaliException e) {
85686       {
85687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85688       };
85689     } catch (...) {
85690       {
85691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85692       };
85693     }
85694   }
85695
85696   jresult = SWIG_csharp_string_callback(result->c_str());
85697   return jresult;
85698 }
85699
85700
85701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
85702   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85703   Dali::Property::Map *arg2 = 0 ;
85704   Dali::Size arg3 ;
85705   Dali::Size *argp3 ;
85706
85707   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85708   arg2 = (Dali::Property::Map *)jarg2;
85709   if (!arg2) {
85710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85711     return ;
85712   }
85713   argp3 = (Dali::Size *)jarg3;
85714   if (!argp3) {
85715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
85716     return ;
85717   }
85718   arg3 = *argp3;
85719   {
85720     try {
85721       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
85722     } catch (std::out_of_range& e) {
85723       {
85724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85725       };
85726     } catch (std::exception& e) {
85727       {
85728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85729       };
85730     } catch (Dali::DaliException e) {
85731       {
85732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85733       };
85734     } catch (...) {
85735       {
85736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85737       };
85738     }
85739   }
85740
85741 }
85742
85743
85744 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
85745   float jresult ;
85746   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85747   float arg2 ;
85748   float result;
85749
85750   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85751   arg2 = (float)jarg2;
85752   {
85753     try {
85754       result = (float)(arg1)->GetHeightForWidth(arg2);
85755     } catch (std::out_of_range& e) {
85756       {
85757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85758       };
85759     } catch (std::exception& e) {
85760       {
85761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85762       };
85763     } catch (Dali::DaliException e) {
85764       {
85765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85766       };
85767     } catch (...) {
85768       {
85769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85770       };
85771     }
85772   }
85773
85774   jresult = result;
85775   return jresult;
85776 }
85777
85778
85779 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
85780   float jresult ;
85781   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85782   float arg2 ;
85783   float result;
85784
85785   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85786   arg2 = (float)jarg2;
85787   {
85788     try {
85789       result = (float)(arg1)->GetWidthForHeight(arg2);
85790     } catch (std::out_of_range& e) {
85791       {
85792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85793       };
85794     } catch (std::exception& e) {
85795       {
85796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85797       };
85798     } catch (Dali::DaliException e) {
85799       {
85800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85801       };
85802     } catch (...) {
85803       {
85804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85805       };
85806     }
85807   }
85808
85809   jresult = result;
85810   return jresult;
85811 }
85812
85813
85814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
85815   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85816   Dali::Vector2 *arg2 = 0 ;
85817
85818   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85819   arg2 = (Dali::Vector2 *)jarg2;
85820   if (!arg2) {
85821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
85822     return ;
85823   }
85824   {
85825     try {
85826       (arg1)->GetNaturalSize(*arg2);
85827     } catch (std::out_of_range& e) {
85828       {
85829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85830       };
85831     } catch (std::exception& e) {
85832       {
85833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85834       };
85835     } catch (Dali::DaliException e) {
85836       {
85837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85838       };
85839     } catch (...) {
85840       {
85841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85842       };
85843     }
85844   }
85845
85846 }
85847
85848
85849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
85850   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85851   float arg2 ;
85852
85853   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85854   arg2 = (int)jarg2;
85855   {
85856     try {
85857       (arg1)->SetDepthIndex(arg2);
85858     } catch (std::out_of_range& e) {
85859       {
85860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85861       };
85862     } catch (std::exception& e) {
85863       {
85864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85865       };
85866     } catch (Dali::DaliException e) {
85867       {
85868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85869       };
85870     } catch (...) {
85871       {
85872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85873       };
85874     }
85875   }
85876
85877 }
85878
85879
85880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
85881   int jresult ;
85882   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85883   int result;
85884
85885   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85886   {
85887     try {
85888       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
85889     } catch (std::out_of_range& e) {
85890       {
85891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85892       };
85893     } catch (std::exception& e) {
85894       {
85895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85896       };
85897     } catch (Dali::DaliException e) {
85898       {
85899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85900       };
85901     } catch (...) {
85902       {
85903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85904       };
85905     }
85906   }
85907
85908   jresult = result;
85909   return jresult;
85910 }
85911
85912
85913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
85914   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85915   Dali::Property::Map *arg2 = 0 ;
85916
85917   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85918   arg2 = (Dali::Property::Map *)jarg2;
85919   if (!arg2) {
85920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
85921     return ;
85922   }
85923   {
85924     try {
85925       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
85926     } catch (std::out_of_range& e) {
85927       {
85928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85929       };
85930     } catch (std::exception& e) {
85931       {
85932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85933       };
85934     } catch (Dali::DaliException e) {
85935       {
85936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85937       };
85938     } catch (...) {
85939       {
85940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85941       };
85942     }
85943   }
85944
85945 }
85946
85947
85948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
85949   void * jresult ;
85950   Dali::Toolkit::VisualFactory result;
85951
85952   {
85953     try {
85954       result = Dali::Toolkit::VisualFactory::Get();
85955     } catch (std::out_of_range& e) {
85956       {
85957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85958       };
85959     } catch (std::exception& e) {
85960       {
85961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85962       };
85963     } catch (Dali::DaliException e) {
85964       {
85965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85966       };
85967     } catch (...) {
85968       {
85969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85970       };
85971     }
85972   }
85973
85974   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
85975   return jresult;
85976 }
85977
85978
85979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
85980   void * jresult ;
85981   Dali::Toolkit::VisualFactory *result = 0 ;
85982
85983   {
85984     try {
85985       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
85986     } catch (std::out_of_range& e) {
85987       {
85988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85989       };
85990     } catch (std::exception& e) {
85991       {
85992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85993       };
85994     } catch (Dali::DaliException e) {
85995       {
85996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85997       };
85998     } catch (...) {
85999       {
86000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86001       };
86002     }
86003   }
86004
86005   jresult = (void *)result;
86006   return jresult;
86007 }
86008
86009
86010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
86011   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86012
86013   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86014   {
86015     try {
86016       delete arg1;
86017     } catch (std::out_of_range& e) {
86018       {
86019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86020       };
86021     } catch (std::exception& e) {
86022       {
86023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86024       };
86025     } catch (Dali::DaliException e) {
86026       {
86027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86028       };
86029     } catch (...) {
86030       {
86031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86032       };
86033     }
86034   }
86035
86036 }
86037
86038
86039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
86040   void * jresult ;
86041   Dali::Toolkit::VisualFactory *arg1 = 0 ;
86042   Dali::Toolkit::VisualFactory *result = 0 ;
86043
86044   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86045   if (!arg1) {
86046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86047     return 0;
86048   }
86049   {
86050     try {
86051       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
86052     } catch (std::out_of_range& e) {
86053       {
86054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86055       };
86056     } catch (std::exception& e) {
86057       {
86058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86059       };
86060     } catch (Dali::DaliException e) {
86061       {
86062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86063       };
86064     } catch (...) {
86065       {
86066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86067       };
86068     }
86069   }
86070
86071   jresult = (void *)result;
86072   return jresult;
86073 }
86074
86075
86076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
86077   void * jresult ;
86078   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86079   Dali::Toolkit::VisualFactory *arg2 = 0 ;
86080   Dali::Toolkit::VisualFactory *result = 0 ;
86081
86082   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86083   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
86084   if (!arg2) {
86085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86086     return 0;
86087   }
86088   {
86089     try {
86090       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
86091     } catch (std::out_of_range& e) {
86092       {
86093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86094       };
86095     } catch (std::exception& e) {
86096       {
86097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86098       };
86099     } catch (Dali::DaliException e) {
86100       {
86101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86102       };
86103     } catch (...) {
86104       {
86105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86106       };
86107     }
86108   }
86109
86110   jresult = (void *)result;
86111   return jresult;
86112 }
86113
86114
86115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
86116   void * jresult ;
86117   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86118   Dali::Property::Map *arg2 = 0 ;
86119   Dali::Toolkit::Visual::Base result;
86120
86121   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86122   arg2 = (Dali::Property::Map *)jarg2;
86123   if (!arg2) {
86124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86125     return 0;
86126   }
86127   {
86128     try {
86129       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
86130     } catch (std::out_of_range& e) {
86131       {
86132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86133       };
86134     } catch (std::exception& e) {
86135       {
86136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86137       };
86138     } catch (Dali::DaliException e) {
86139       {
86140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86141       };
86142     } catch (...) {
86143       {
86144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86145       };
86146     }
86147   }
86148
86149   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86150   return jresult;
86151 }
86152
86153
86154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
86155   void * jresult ;
86156   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86157   std::string *arg2 = 0 ;
86158   Dali::ImageDimensions arg3 ;
86159   Dali::ImageDimensions *argp3 ;
86160   Dali::Toolkit::Visual::Base result;
86161
86162   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86163   if (!jarg2) {
86164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86165     return 0;
86166   }
86167   std::string arg2_str(jarg2);
86168   arg2 = &arg2_str;
86169   argp3 = (Dali::ImageDimensions *)jarg3;
86170   if (!argp3) {
86171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86172     return 0;
86173   }
86174   arg3 = *argp3;
86175   {
86176     try {
86177       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
86178     } catch (std::out_of_range& e) {
86179       {
86180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86181       };
86182     } catch (std::exception& e) {
86183       {
86184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86185       };
86186     } catch (Dali::DaliException e) {
86187       {
86188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86189       };
86190     } catch (...) {
86191       {
86192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86193       };
86194     }
86195   }
86196
86197   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86198
86199   //argout typemap for const std::string&
86200
86201   return jresult;
86202 }
86203
86204
86205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
86206   void * jresult ;
86207   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86208
86209   {
86210     try {
86211       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
86212     } catch (std::out_of_range& e) {
86213       {
86214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86215       };
86216     } catch (std::exception& e) {
86217       {
86218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86219       };
86220     } catch (Dali::DaliException e) {
86221       {
86222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86223       };
86224     } catch (...) {
86225       {
86226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86227       };
86228     }
86229   }
86230
86231   jresult = (void *)result;
86232   return jresult;
86233 }
86234
86235
86236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86237   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86238
86239   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86240   {
86241     try {
86242       delete arg1;
86243     } catch (std::out_of_range& e) {
86244       {
86245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86246       };
86247     } catch (std::exception& e) {
86248       {
86249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86250       };
86251     } catch (Dali::DaliException e) {
86252       {
86253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86254       };
86255     } catch (...) {
86256       {
86257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86258       };
86259     }
86260   }
86261
86262 }
86263
86264
86265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86266   void * jresult ;
86267   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86268   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86269
86270   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86271   if (!arg1) {
86272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86273     return 0;
86274   }
86275   {
86276     try {
86277       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86278     } catch (std::out_of_range& e) {
86279       {
86280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86281       };
86282     } catch (std::exception& e) {
86283       {
86284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86285       };
86286     } catch (Dali::DaliException e) {
86287       {
86288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86289       };
86290     } catch (...) {
86291       {
86292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86293       };
86294     }
86295   }
86296
86297   jresult = (void *)result;
86298   return jresult;
86299 }
86300
86301
86302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86303   void * jresult ;
86304   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86305   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86306   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86307
86308   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86309   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86310   if (!arg2) {
86311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86312     return 0;
86313   }
86314   {
86315     try {
86316       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86317     } catch (std::out_of_range& e) {
86318       {
86319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86320       };
86321     } catch (std::exception& e) {
86322       {
86323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86324       };
86325     } catch (Dali::DaliException e) {
86326       {
86327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86328       };
86329     } catch (...) {
86330       {
86331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86332       };
86333     }
86334   }
86335
86336   jresult = (void *)result;
86337   return jresult;
86338 }
86339
86340
86341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86342   void * jresult ;
86343   Dali::Toolkit::AsyncImageLoader result;
86344
86345   {
86346     try {
86347       result = Dali::Toolkit::AsyncImageLoader::New();
86348     } catch (std::out_of_range& e) {
86349       {
86350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86351       };
86352     } catch (std::exception& e) {
86353       {
86354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86355       };
86356     } catch (Dali::DaliException e) {
86357       {
86358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86359       };
86360     } catch (...) {
86361       {
86362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86363       };
86364     }
86365   }
86366
86367   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86368   return jresult;
86369 }
86370
86371
86372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86373   void * jresult ;
86374   Dali::BaseHandle arg1 ;
86375   Dali::BaseHandle *argp1 ;
86376   Dali::Toolkit::AsyncImageLoader result;
86377
86378   argp1 = (Dali::BaseHandle *)jarg1;
86379   if (!argp1) {
86380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86381     return 0;
86382   }
86383   arg1 = *argp1;
86384   {
86385     try {
86386       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86387     } catch (std::out_of_range& e) {
86388       {
86389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86390       };
86391     } catch (std::exception& e) {
86392       {
86393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86394       };
86395     } catch (Dali::DaliException e) {
86396       {
86397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86398       };
86399     } catch (...) {
86400       {
86401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86402       };
86403     }
86404   }
86405
86406   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86407   return jresult;
86408 }
86409
86410
86411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86412   unsigned int jresult ;
86413   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86414   std::string *arg2 = 0 ;
86415   uint32_t result;
86416
86417   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86418   if (!jarg2) {
86419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86420     return 0;
86421   }
86422   std::string arg2_str(jarg2);
86423   arg2 = &arg2_str;
86424   {
86425     try {
86426       result = (arg1)->Load((std::string const &)*arg2);
86427     } catch (std::out_of_range& e) {
86428       {
86429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86430       };
86431     } catch (std::exception& e) {
86432       {
86433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86434       };
86435     } catch (Dali::DaliException e) {
86436       {
86437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86438       };
86439     } catch (...) {
86440       {
86441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86442       };
86443     }
86444   }
86445
86446   jresult = result;
86447
86448   //argout typemap for const std::string&
86449
86450   return jresult;
86451 }
86452
86453
86454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86455   unsigned int jresult ;
86456   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86457   std::string *arg2 = 0 ;
86458   Dali::ImageDimensions arg3 ;
86459   Dali::ImageDimensions *argp3 ;
86460   uint32_t result;
86461
86462   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86463   if (!jarg2) {
86464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86465     return 0;
86466   }
86467   std::string arg2_str(jarg2);
86468   arg2 = &arg2_str;
86469   argp3 = (Dali::ImageDimensions *)jarg3;
86470   if (!argp3) {
86471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86472     return 0;
86473   }
86474   arg3 = *argp3;
86475   {
86476     try {
86477       result = (arg1)->Load((std::string const &)*arg2,arg3);
86478     } catch (std::out_of_range& e) {
86479       {
86480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86481       };
86482     } catch (std::exception& e) {
86483       {
86484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86485       };
86486     } catch (Dali::DaliException e) {
86487       {
86488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86489       };
86490     } catch (...) {
86491       {
86492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86493       };
86494     }
86495   }
86496
86497   jresult = result;
86498
86499   //argout typemap for const std::string&
86500
86501   return jresult;
86502 }
86503
86504
86505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86506   unsigned int jresult ;
86507   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86508   std::string *arg2 = 0 ;
86509   Dali::ImageDimensions arg3 ;
86510   Dali::FittingMode::Type arg4 ;
86511   Dali::SamplingMode::Type arg5 ;
86512   bool arg6 ;
86513   Dali::ImageDimensions *argp3 ;
86514   uint32_t result;
86515
86516   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86517   if (!jarg2) {
86518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86519     return 0;
86520   }
86521   std::string arg2_str(jarg2);
86522   arg2 = &arg2_str;
86523   argp3 = (Dali::ImageDimensions *)jarg3;
86524   if (!argp3) {
86525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86526     return 0;
86527   }
86528   arg3 = *argp3;
86529   arg4 = (Dali::FittingMode::Type)jarg4;
86530   arg5 = (Dali::SamplingMode::Type)jarg5;
86531   arg6 = jarg6 ? true : false;
86532   {
86533     try {
86534       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86535     } catch (std::out_of_range& e) {
86536       {
86537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86538       };
86539     } catch (std::exception& e) {
86540       {
86541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86542       };
86543     } catch (Dali::DaliException e) {
86544       {
86545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86546       };
86547     } catch (...) {
86548       {
86549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86550       };
86551     }
86552   }
86553
86554   jresult = result;
86555
86556   //argout typemap for const std::string&
86557
86558   return jresult;
86559 }
86560
86561
86562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86563   unsigned int jresult ;
86564   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86565   uint32_t arg2 ;
86566   bool result;
86567
86568   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86569   arg2 = (uint32_t)jarg2;
86570   {
86571     try {
86572       result = (bool)(arg1)->Cancel(arg2);
86573     } catch (std::out_of_range& e) {
86574       {
86575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86576       };
86577     } catch (std::exception& e) {
86578       {
86579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86580       };
86581     } catch (Dali::DaliException e) {
86582       {
86583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86584       };
86585     } catch (...) {
86586       {
86587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86588       };
86589     }
86590   }
86591
86592   jresult = result;
86593   return jresult;
86594 }
86595
86596
86597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86598   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86599
86600   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86601   {
86602     try {
86603       (arg1)->CancelAll();
86604     } catch (std::out_of_range& e) {
86605       {
86606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86607       };
86608     } catch (std::exception& e) {
86609       {
86610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86611       };
86612     } catch (Dali::DaliException e) {
86613       {
86614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86615       };
86616     } catch (...) {
86617       {
86618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86619       };
86620     }
86621   }
86622
86623 }
86624
86625
86626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86627   void * jresult ;
86628   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86629   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86630
86631   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86632   {
86633     try {
86634       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
86635     } catch (std::out_of_range& e) {
86636       {
86637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86638       };
86639     } catch (std::exception& e) {
86640       {
86641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86642       };
86643     } catch (Dali::DaliException e) {
86644       {
86645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86646       };
86647     } catch (...) {
86648       {
86649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86650       };
86651     }
86652   }
86653
86654   jresult = (void *)result;
86655   return jresult;
86656 }
86657
86658
86659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
86660   void * jresult ;
86661   std::string *arg1 = 0 ;
86662   Dali::PixelData result;
86663
86664   if (!jarg1) {
86665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86666     return 0;
86667   }
86668   std::string arg1_str(jarg1);
86669   arg1 = &arg1_str;
86670   {
86671     try {
86672       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
86673     } catch (std::out_of_range& e) {
86674       {
86675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86676       };
86677     } catch (std::exception& e) {
86678       {
86679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86680       };
86681     } catch (Dali::DaliException e) {
86682       {
86683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86684       };
86685     } catch (...) {
86686       {
86687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86688       };
86689     }
86690   }
86691
86692   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86693
86694   //argout typemap for const std::string&
86695
86696   return jresult;
86697 }
86698
86699
86700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
86701   void * jresult ;
86702   std::string *arg1 = 0 ;
86703   Dali::ImageDimensions arg2 ;
86704   Dali::ImageDimensions *argp2 ;
86705   Dali::PixelData result;
86706
86707   if (!jarg1) {
86708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86709     return 0;
86710   }
86711   std::string arg1_str(jarg1);
86712   arg1 = &arg1_str;
86713   argp2 = (Dali::ImageDimensions *)jarg2;
86714   if (!argp2) {
86715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86716     return 0;
86717   }
86718   arg2 = *argp2;
86719   {
86720     try {
86721       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
86722     } catch (std::out_of_range& e) {
86723       {
86724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86725       };
86726     } catch (std::exception& e) {
86727       {
86728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86729       };
86730     } catch (Dali::DaliException e) {
86731       {
86732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86733       };
86734     } catch (...) {
86735       {
86736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86737       };
86738     }
86739   }
86740
86741   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86742
86743   //argout typemap for const std::string&
86744
86745   return jresult;
86746 }
86747
86748
86749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
86750   void * jresult ;
86751   std::string *arg1 = 0 ;
86752   Dali::ImageDimensions arg2 ;
86753   Dali::FittingMode::Type arg3 ;
86754   Dali::SamplingMode::Type arg4 ;
86755   bool arg5 ;
86756   Dali::ImageDimensions *argp2 ;
86757   Dali::PixelData result;
86758
86759   if (!jarg1) {
86760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86761     return 0;
86762   }
86763   std::string arg1_str(jarg1);
86764   arg1 = &arg1_str;
86765   argp2 = (Dali::ImageDimensions *)jarg2;
86766   if (!argp2) {
86767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86768     return 0;
86769   }
86770   arg2 = *argp2;
86771   arg3 = (Dali::FittingMode::Type)jarg3;
86772   arg4 = (Dali::SamplingMode::Type)jarg4;
86773   arg5 = jarg5 ? true : false;
86774   {
86775     try {
86776       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
86777     } catch (std::out_of_range& e) {
86778       {
86779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86780       };
86781     } catch (std::exception& e) {
86782       {
86783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86784       };
86785     } catch (Dali::DaliException e) {
86786       {
86787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86788       };
86789     } catch (...) {
86790       {
86791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86792       };
86793     }
86794   }
86795
86796   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86797
86798   //argout typemap for const std::string&
86799
86800   return jresult;
86801 }
86802
86803
86804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
86805   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86806
86807   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86808   {
86809     try {
86810       delete arg1;
86811     } catch (std::out_of_range& e) {
86812       {
86813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86814       };
86815     } catch (std::exception& e) {
86816       {
86817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86818       };
86819     } catch (Dali::DaliException e) {
86820       {
86821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86822       };
86823     } catch (...) {
86824       {
86825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86826       };
86827     }
86828   }
86829
86830 }
86831
86832
86833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
86834   void * jresult ;
86835   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86836   Dali::Actor arg2 ;
86837   Dali::Actor arg3 ;
86838   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
86839   Dali::Actor *argp2 ;
86840   Dali::Actor *argp3 ;
86841   Dali::Actor result;
86842
86843   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86844   argp2 = (Dali::Actor *)jarg2;
86845   if (!argp2) {
86846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86847     return 0;
86848   }
86849   arg2 = *argp2;
86850   argp3 = (Dali::Actor *)jarg3;
86851   if (!argp3) {
86852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86853     return 0;
86854   }
86855   arg3 = *argp3;
86856   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
86857   {
86858     try {
86859       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
86860     } catch (std::out_of_range& e) {
86861       {
86862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86863       };
86864     } catch (std::exception& e) {
86865       {
86866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86867       };
86868     } catch (Dali::DaliException e) {
86869       {
86870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86871       };
86872     } catch (...) {
86873       {
86874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86875       };
86876     }
86877   }
86878
86879   jresult = new Dali::Actor((const Dali::Actor &)result);
86880   return jresult;
86881 }
86882
86883
86884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
86885   void * jresult ;
86886   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
86887
86888   {
86889     try {
86890       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
86891     } catch (std::out_of_range& e) {
86892       {
86893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86894       };
86895     } catch (std::exception& e) {
86896       {
86897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86898       };
86899     } catch (Dali::DaliException e) {
86900       {
86901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86902       };
86903     } catch (...) {
86904       {
86905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86906       };
86907     }
86908   }
86909
86910   jresult = (void *)result;
86911   return jresult;
86912 }
86913
86914
86915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
86916   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
86917   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
86918   if (director) {
86919     director->swig_connect_director(callback0);
86920   }
86921 }
86922
86923
86924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
86925   void * jresult ;
86926   Dali::FrameCallbackInterface *result = 0 ;
86927
86928   {
86929     try {
86930       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
86931     } catch (std::out_of_range& e) {
86932       {
86933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86934       };
86935     } catch (std::exception& e) {
86936       {
86937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86938       };
86939     } catch (Dali::DaliException e) {
86940       {
86941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86942       };
86943     } catch (...) {
86944       {
86945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86946       };
86947     }
86948   }
86949
86950   jresult = (void *)result;
86951   return jresult;
86952 }
86953
86954 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
86955   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86956   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
86957   return proxy->GetPosition(id, *vector3);
86958 }
86959
86960 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
86961   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86962   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
86963   return proxy->SetPosition(id, *vector3);
86964 }
86965
86966 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
86967   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86968   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
86969   return proxy->BakePosition(id, *vector3);
86970 }
86971
86972 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
86973   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86974   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
86975   return proxy->GetSize(id, *vector3);
86976 }
86977
86978 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
86979   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86980   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
86981   return proxy->SetSize(id, *vector3);
86982 }
86983 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
86984   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86985   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
86986   return proxy->BakeSize(id, *vector3);
86987 }
86988
86989 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
86990   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86991   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
86992   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
86993   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
86994 }
86995
86996 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
86997   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86998   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
86999   return proxy->GetScale(id,* vector3);
87000 }
87001
87002 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
87003   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87004   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87005   return proxy->SetScale(id, *vector3);
87006 }
87007
87008 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
87009   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87010   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87011   return proxy->BakeScale(id, *vector3);
87012 }
87013
87014 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
87015   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87016   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87017   return proxy->GetColor(id, *vector4);
87018 }
87019
87020 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
87021   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87022   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87023   return proxy->SetColor(id, *vector4);
87024 }
87025
87026 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
87027   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87028   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87029   return proxy->BakeColor(id, *vector4);
87030 }
87031
87032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
87033   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
87034   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87035
87036   Dali::Stage *arg1 = (Dali::Stage *) 0;
87037   Dali::Actor *arg3 = 0;
87038
87039   arg1 = (Dali::Stage *)jarg1;
87040   arg3 = (Dali::Actor *)jarg3;
87041
87042   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
87043   return;
87044 }
87045
87046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
87047
87048   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
87049   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87050
87051   Dali::Stage *arg1 = (Dali::Stage *) 0;
87052
87053   arg1 = (Dali::Stage *)jarg1;
87054
87055   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
87056   return;
87057 }
87058
87059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
87060   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
87061   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
87062   if (director) {
87063     director->swig_connect_director(callback0);
87064   }
87065 }
87066
87067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
87068   KeyboardFocusManager arg1 ;
87069   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
87070   KeyboardFocusManager *argp1 ;
87071
87072   argp1 = (KeyboardFocusManager *)jarg1;
87073   if (!argp1) {
87074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
87075     return ;
87076   }
87077   arg1 = *argp1;
87078   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
87079   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
87080   {
87081     try {
87082       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
87083     } catch (std::out_of_range& e) {
87084       {
87085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87086       };
87087     } catch (std::exception& e) {
87088       {
87089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87090       };
87091     } catch (Dali::DaliException e) {
87092       {
87093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87094       };
87095     } catch (...) {
87096       {
87097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87098       };
87099     }
87100   }
87101
87102 }
87103
87104
87105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
87106   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87107
87108   arg1 = (std::vector< unsigned int > *)jarg1;
87109   {
87110     try {
87111       (arg1)->clear();
87112     } catch (std::out_of_range& e) {
87113       {
87114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87115       };
87116     } catch (std::exception& e) {
87117       {
87118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87119       };
87120     } catch (Dali::DaliException e) {
87121       {
87122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87123       };
87124     } catch (...) {
87125       {
87126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87127       };
87128     }
87129   }
87130
87131 }
87132
87133
87134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
87135   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87136   unsigned int *arg2 = 0 ;
87137   unsigned int temp2 ;
87138
87139   arg1 = (std::vector< unsigned int > *)jarg1;
87140   temp2 = (unsigned int)jarg2;
87141   arg2 = &temp2;
87142   {
87143     try {
87144       (arg1)->push_back((unsigned int const &)*arg2);
87145     } catch (std::out_of_range& e) {
87146       {
87147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87148       };
87149     } catch (std::exception& e) {
87150       {
87151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87152       };
87153     } catch (Dali::DaliException e) {
87154       {
87155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87156       };
87157     } catch (...) {
87158       {
87159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87160       };
87161     }
87162   }
87163
87164 }
87165
87166
87167 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
87168   unsigned long jresult ;
87169   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87170   std::vector< unsigned int >::size_type result;
87171
87172   arg1 = (std::vector< unsigned int > *)jarg1;
87173   {
87174     try {
87175       result = ((std::vector< unsigned int > const *)arg1)->size();
87176     } catch (std::out_of_range& e) {
87177       {
87178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87179       };
87180     } catch (std::exception& e) {
87181       {
87182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87183       };
87184     } catch (Dali::DaliException e) {
87185       {
87186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87187       };
87188     } catch (...) {
87189       {
87190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87191       };
87192     }
87193   }
87194
87195   jresult = (unsigned long)result;
87196   return jresult;
87197 }
87198
87199
87200 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
87201   unsigned long jresult ;
87202   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87203   std::vector< unsigned int >::size_type result;
87204
87205   arg1 = (std::vector< unsigned int > *)jarg1;
87206   {
87207     try {
87208       result = ((std::vector< unsigned int > const *)arg1)->capacity();
87209     } catch (std::out_of_range& e) {
87210       {
87211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87212       };
87213     } catch (std::exception& e) {
87214       {
87215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87216       };
87217     } catch (Dali::DaliException e) {
87218       {
87219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87220       };
87221     } catch (...) {
87222       {
87223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87224       };
87225     }
87226   }
87227
87228   jresult = (unsigned long)result;
87229   return jresult;
87230 }
87231
87232
87233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
87234   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87235   std::vector< unsigned int >::size_type arg2 ;
87236
87237   arg1 = (std::vector< unsigned int > *)jarg1;
87238   arg2 = (std::vector< unsigned int >::size_type)jarg2;
87239   {
87240     try {
87241       (arg1)->reserve(arg2);
87242     } catch (std::out_of_range& e) {
87243       {
87244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87245       };
87246     } catch (std::exception& e) {
87247       {
87248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87249       };
87250     } catch (Dali::DaliException e) {
87251       {
87252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87253       };
87254     } catch (...) {
87255       {
87256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87257       };
87258     }
87259   }
87260
87261 }
87262
87263
87264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
87265   void * jresult ;
87266   std::vector< unsigned int > *result = 0 ;
87267
87268   {
87269     try {
87270       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
87271     } catch (std::out_of_range& e) {
87272       {
87273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87274       };
87275     } catch (std::exception& e) {
87276       {
87277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87278       };
87279     } catch (Dali::DaliException e) {
87280       {
87281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87282       };
87283     } catch (...) {
87284       {
87285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87286       };
87287     }
87288   }
87289
87290   jresult = (void *)result;
87291   return jresult;
87292 }
87293
87294
87295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
87296   void * jresult ;
87297   std::vector< unsigned int > *arg1 = 0 ;
87298   std::vector< unsigned int > *result = 0 ;
87299
87300   arg1 = (std::vector< unsigned int > *)jarg1;
87301   if (!arg1) {
87302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87303     return 0;
87304   }
87305   {
87306     try {
87307       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
87308     } catch (std::out_of_range& e) {
87309       {
87310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87311       };
87312     } catch (std::exception& e) {
87313       {
87314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87315       };
87316     } catch (Dali::DaliException e) {
87317       {
87318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87319       };
87320     } catch (...) {
87321       {
87322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87323       };
87324     }
87325   }
87326
87327   jresult = (void *)result;
87328   return jresult;
87329 }
87330
87331
87332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
87333   void * jresult ;
87334   int arg1 ;
87335   std::vector< unsigned int > *result = 0 ;
87336
87337   arg1 = (int)jarg1;
87338   {
87339     try {
87340       try {
87341         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
87342       }
87343       catch(std::out_of_range &_e) {
87344         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87345         return 0;
87346       }
87347
87348     } catch (std::out_of_range& e) {
87349       {
87350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87351       };
87352     } catch (std::exception& e) {
87353       {
87354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87355       };
87356     } catch (Dali::DaliException e) {
87357       {
87358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87359       };
87360     } catch (...) {
87361       {
87362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87363       };
87364     }
87365   }
87366
87367   jresult = (void *)result;
87368   return jresult;
87369 }
87370
87371
87372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
87373   unsigned int jresult ;
87374   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87375   int arg2 ;
87376   unsigned int result;
87377
87378   arg1 = (std::vector< unsigned int > *)jarg1;
87379   arg2 = (int)jarg2;
87380   {
87381     try {
87382       try {
87383         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
87384       }
87385       catch(std::out_of_range &_e) {
87386         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87387         return 0;
87388       }
87389
87390     } catch (std::out_of_range& e) {
87391       {
87392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87393       };
87394     } catch (std::exception& e) {
87395       {
87396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87397       };
87398     } catch (Dali::DaliException e) {
87399       {
87400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87401       };
87402     } catch (...) {
87403       {
87404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87405       };
87406     }
87407   }
87408
87409   jresult = result;
87410   return jresult;
87411 }
87412
87413
87414 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
87415   unsigned int jresult ;
87416   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87417   int arg2 ;
87418   unsigned int *result = 0 ;
87419
87420   arg1 = (std::vector< unsigned int > *)jarg1;
87421   arg2 = (int)jarg2;
87422   {
87423     try {
87424       try {
87425         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
87426       }
87427       catch(std::out_of_range &_e) {
87428         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87429         return 0;
87430       }
87431
87432     } catch (std::out_of_range& e) {
87433       {
87434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87435       };
87436     } catch (std::exception& e) {
87437       {
87438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87439       };
87440     } catch (Dali::DaliException e) {
87441       {
87442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87443       };
87444     } catch (...) {
87445       {
87446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87447       };
87448     }
87449   }
87450
87451   jresult = *result;
87452   return jresult;
87453 }
87454
87455
87456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
87457   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87458   int arg2 ;
87459   unsigned int *arg3 = 0 ;
87460   unsigned int temp3 ;
87461
87462   arg1 = (std::vector< unsigned int > *)jarg1;
87463   arg2 = (int)jarg2;
87464   temp3 = (unsigned int)jarg3;
87465   arg3 = &temp3;
87466   {
87467     try {
87468       try {
87469         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87470       }
87471       catch(std::out_of_range &_e) {
87472         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87473         return ;
87474       }
87475
87476     } catch (std::out_of_range& e) {
87477       {
87478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87479       };
87480     } catch (std::exception& e) {
87481       {
87482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87483       };
87484     } catch (Dali::DaliException e) {
87485       {
87486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87487       };
87488     } catch (...) {
87489       {
87490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87491       };
87492     }
87493   }
87494
87495 }
87496
87497
87498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87499   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87500   std::vector< unsigned int > *arg2 = 0 ;
87501
87502   arg1 = (std::vector< unsigned int > *)jarg1;
87503   arg2 = (std::vector< unsigned int > *)jarg2;
87504   if (!arg2) {
87505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87506     return ;
87507   }
87508   {
87509     try {
87510       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87511     } catch (std::out_of_range& e) {
87512       {
87513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87514       };
87515     } catch (std::exception& e) {
87516       {
87517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87518       };
87519     } catch (Dali::DaliException e) {
87520       {
87521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87522       };
87523     } catch (...) {
87524       {
87525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87526       };
87527     }
87528   }
87529
87530 }
87531
87532
87533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87534   void * jresult ;
87535   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87536   int arg2 ;
87537   int arg3 ;
87538   std::vector< unsigned int > *result = 0 ;
87539
87540   arg1 = (std::vector< unsigned int > *)jarg1;
87541   arg2 = (int)jarg2;
87542   arg3 = (int)jarg3;
87543   {
87544     try {
87545       try {
87546         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87547       }
87548       catch(std::out_of_range &_e) {
87549         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87550         return 0;
87551       }
87552       catch(std::invalid_argument &_e) {
87553         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87554         return 0;
87555       }
87556
87557     } catch (std::out_of_range& e) {
87558       {
87559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87560       };
87561     } catch (std::exception& e) {
87562       {
87563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87564       };
87565     } catch (Dali::DaliException e) {
87566       {
87567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87568       };
87569     } catch (...) {
87570       {
87571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87572       };
87573     }
87574   }
87575
87576   jresult = (void *)result;
87577   return jresult;
87578 }
87579
87580
87581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87582   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87583   int arg2 ;
87584   unsigned int *arg3 = 0 ;
87585   unsigned int temp3 ;
87586
87587   arg1 = (std::vector< unsigned int > *)jarg1;
87588   arg2 = (int)jarg2;
87589   temp3 = (unsigned int)jarg3;
87590   arg3 = &temp3;
87591   {
87592     try {
87593       try {
87594         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87595       }
87596       catch(std::out_of_range &_e) {
87597         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87598         return ;
87599       }
87600
87601     } catch (std::out_of_range& e) {
87602       {
87603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87604       };
87605     } catch (std::exception& e) {
87606       {
87607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87608       };
87609     } catch (Dali::DaliException e) {
87610       {
87611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87612       };
87613     } catch (...) {
87614       {
87615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87616       };
87617     }
87618   }
87619
87620 }
87621
87622
87623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87624   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87625   int arg2 ;
87626   std::vector< unsigned int > *arg3 = 0 ;
87627
87628   arg1 = (std::vector< unsigned int > *)jarg1;
87629   arg2 = (int)jarg2;
87630   arg3 = (std::vector< unsigned int > *)jarg3;
87631   if (!arg3) {
87632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87633     return ;
87634   }
87635   {
87636     try {
87637       try {
87638         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87639       }
87640       catch(std::out_of_range &_e) {
87641         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87642         return ;
87643       }
87644
87645     } catch (std::out_of_range& e) {
87646       {
87647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87648       };
87649     } catch (std::exception& e) {
87650       {
87651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87652       };
87653     } catch (Dali::DaliException e) {
87654       {
87655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87656       };
87657     } catch (...) {
87658       {
87659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87660       };
87661     }
87662   }
87663
87664 }
87665
87666
87667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
87668   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87669   int arg2 ;
87670
87671   arg1 = (std::vector< unsigned int > *)jarg1;
87672   arg2 = (int)jarg2;
87673   {
87674     try {
87675       try {
87676         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
87677       }
87678       catch(std::out_of_range &_e) {
87679         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87680         return ;
87681       }
87682
87683     } catch (std::out_of_range& e) {
87684       {
87685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87686       };
87687     } catch (std::exception& e) {
87688       {
87689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87690       };
87691     } catch (Dali::DaliException e) {
87692       {
87693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87694       };
87695     } catch (...) {
87696       {
87697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87698       };
87699     }
87700   }
87701
87702 }
87703
87704
87705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87706   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87707   int arg2 ;
87708   int arg3 ;
87709
87710   arg1 = (std::vector< unsigned int > *)jarg1;
87711   arg2 = (int)jarg2;
87712   arg3 = (int)jarg3;
87713   {
87714     try {
87715       try {
87716         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
87717       }
87718       catch(std::out_of_range &_e) {
87719         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87720         return ;
87721       }
87722       catch(std::invalid_argument &_e) {
87723         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87724         return ;
87725       }
87726
87727     } catch (std::out_of_range& e) {
87728       {
87729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87730       };
87731     } catch (std::exception& e) {
87732       {
87733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87734       };
87735     } catch (Dali::DaliException e) {
87736       {
87737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87738       };
87739     } catch (...) {
87740       {
87741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87742       };
87743     }
87744   }
87745
87746 }
87747
87748
87749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
87750   void * jresult ;
87751   unsigned int *arg1 = 0 ;
87752   int arg2 ;
87753   unsigned int temp1 ;
87754   std::vector< unsigned int > *result = 0 ;
87755
87756   temp1 = (unsigned int)jarg1;
87757   arg1 = &temp1;
87758   arg2 = (int)jarg2;
87759   {
87760     try {
87761       try {
87762         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
87763       }
87764       catch(std::out_of_range &_e) {
87765         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87766         return 0;
87767       }
87768
87769     } catch (std::out_of_range& e) {
87770       {
87771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87772       };
87773     } catch (std::exception& e) {
87774       {
87775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87776       };
87777     } catch (Dali::DaliException e) {
87778       {
87779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87780       };
87781     } catch (...) {
87782       {
87783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87784       };
87785     }
87786   }
87787
87788   jresult = (void *)result;
87789   return jresult;
87790 }
87791
87792
87793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
87794   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87795
87796   arg1 = (std::vector< unsigned int > *)jarg1;
87797   {
87798     try {
87799       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
87800     } catch (std::out_of_range& e) {
87801       {
87802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87803       };
87804     } catch (std::exception& e) {
87805       {
87806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87807       };
87808     } catch (Dali::DaliException e) {
87809       {
87810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87811       };
87812     } catch (...) {
87813       {
87814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87815       };
87816     }
87817   }
87818
87819 }
87820
87821
87822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87823   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87824   int arg2 ;
87825   int arg3 ;
87826
87827   arg1 = (std::vector< unsigned int > *)jarg1;
87828   arg2 = (int)jarg2;
87829   arg3 = (int)jarg3;
87830   {
87831     try {
87832       try {
87833         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87834       }
87835       catch(std::out_of_range &_e) {
87836         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87837         return ;
87838       }
87839       catch(std::invalid_argument &_e) {
87840         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87841         return ;
87842       }
87843
87844     } catch (std::out_of_range& e) {
87845       {
87846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87847       };
87848     } catch (std::exception& e) {
87849       {
87850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87851       };
87852     } catch (Dali::DaliException e) {
87853       {
87854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87855       };
87856     } catch (...) {
87857       {
87858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87859       };
87860     }
87861   }
87862
87863 }
87864
87865
87866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87867   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87868   int arg2 ;
87869   std::vector< unsigned int > *arg3 = 0 ;
87870
87871   arg1 = (std::vector< unsigned int > *)jarg1;
87872   arg2 = (int)jarg2;
87873   arg3 = (std::vector< unsigned int > *)jarg3;
87874   if (!arg3) {
87875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87876     return ;
87877   }
87878   {
87879     try {
87880       try {
87881         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87882       }
87883       catch(std::out_of_range &_e) {
87884         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87885         return ;
87886       }
87887
87888     } catch (std::out_of_range& e) {
87889       {
87890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87891       };
87892     } catch (std::exception& e) {
87893       {
87894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87895       };
87896     } catch (Dali::DaliException e) {
87897       {
87898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87899       };
87900     } catch (...) {
87901       {
87902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87903       };
87904     }
87905   }
87906
87907 }
87908
87909
87910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
87911   unsigned int jresult ;
87912   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87913   unsigned int *arg2 = 0 ;
87914   unsigned int temp2 ;
87915   bool result;
87916
87917   arg1 = (std::vector< unsigned int > *)jarg1;
87918   temp2 = (unsigned int)jarg2;
87919   arg2 = &temp2;
87920   {
87921     try {
87922       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
87923     } catch (std::out_of_range& e) {
87924       {
87925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87926       };
87927     } catch (std::exception& e) {
87928       {
87929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87930       };
87931     } catch (Dali::DaliException e) {
87932       {
87933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87934       };
87935     } catch (...) {
87936       {
87937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87938       };
87939     }
87940   }
87941
87942   jresult = result;
87943   return jresult;
87944 }
87945
87946
87947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
87948   int jresult ;
87949   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87950   unsigned int *arg2 = 0 ;
87951   unsigned int temp2 ;
87952   int result;
87953
87954   arg1 = (std::vector< unsigned int > *)jarg1;
87955   temp2 = (unsigned int)jarg2;
87956   arg2 = &temp2;
87957   {
87958     try {
87959       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
87960     } catch (std::out_of_range& e) {
87961       {
87962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87963       };
87964     } catch (std::exception& e) {
87965       {
87966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87967       };
87968     } catch (Dali::DaliException e) {
87969       {
87970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87971       };
87972     } catch (...) {
87973       {
87974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87975       };
87976     }
87977   }
87978
87979   jresult = result;
87980   return jresult;
87981 }
87982
87983
87984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
87985   int jresult ;
87986   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87987   unsigned int *arg2 = 0 ;
87988   unsigned int temp2 ;
87989   int result;
87990
87991   arg1 = (std::vector< unsigned int > *)jarg1;
87992   temp2 = (unsigned int)jarg2;
87993   arg2 = &temp2;
87994   {
87995     try {
87996       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
87997     } catch (std::out_of_range& e) {
87998       {
87999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88000       };
88001     } catch (std::exception& e) {
88002       {
88003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88004       };
88005     } catch (Dali::DaliException e) {
88006       {
88007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88008       };
88009     } catch (...) {
88010       {
88011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88012       };
88013     }
88014   }
88015
88016   jresult = result;
88017   return jresult;
88018 }
88019
88020
88021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
88022   unsigned int jresult ;
88023   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88024   unsigned int *arg2 = 0 ;
88025   unsigned int temp2 ;
88026   bool result;
88027
88028   arg1 = (std::vector< unsigned int > *)jarg1;
88029   temp2 = (unsigned int)jarg2;
88030   arg2 = &temp2;
88031   {
88032     try {
88033       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
88034     } catch (std::out_of_range& e) {
88035       {
88036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88037       };
88038     } catch (std::exception& e) {
88039       {
88040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88041       };
88042     } catch (Dali::DaliException e) {
88043       {
88044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88045       };
88046     } catch (...) {
88047       {
88048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88049       };
88050     }
88051   }
88052
88053   jresult = result;
88054   return jresult;
88055 }
88056
88057
88058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
88059   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88060
88061   arg1 = (std::vector< unsigned int > *)jarg1;
88062   {
88063     try {
88064       delete arg1;
88065     } catch (std::out_of_range& e) {
88066       {
88067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88068       };
88069     } catch (std::exception& e) {
88070       {
88071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88072       };
88073     } catch (Dali::DaliException e) {
88074       {
88075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88076       };
88077     } catch (...) {
88078       {
88079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88080       };
88081     }
88082   }
88083
88084 }
88085
88086
88087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
88088   void * jresult ;
88089   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88090
88091   {
88092     try {
88093       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
88094     } catch (std::out_of_range& e) {
88095       {
88096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88097       };
88098     } catch (std::exception& e) {
88099       {
88100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88101       };
88102     } catch (Dali::DaliException e) {
88103       {
88104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88105       };
88106     } catch (...) {
88107       {
88108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88109       };
88110     }
88111   }
88112
88113   jresult = (void *)result;
88114   return jresult;
88115 }
88116
88117
88118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
88119   void * jresult ;
88120   unsigned int arg1 ;
88121   Dali::Actor arg2 ;
88122   Dali::Actor *argp2 ;
88123   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88124
88125   arg1 = (unsigned int)jarg1;
88126   argp2 = (Dali::Actor *)jarg2;
88127   if (!argp2) {
88128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88129     return 0;
88130   }
88131   arg2 = *argp2;
88132   {
88133     try {
88134       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
88135     } catch (std::out_of_range& e) {
88136       {
88137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88138       };
88139     } catch (std::exception& e) {
88140       {
88141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88142       };
88143     } catch (Dali::DaliException e) {
88144       {
88145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88146       };
88147     } catch (...) {
88148       {
88149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88150       };
88151     }
88152   }
88153
88154   jresult = (void *)result;
88155   return jresult;
88156 }
88157
88158
88159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
88160   void * jresult ;
88161   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88162   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88163
88164   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88165   if (!arg1) {
88166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88167     return 0;
88168   }
88169   {
88170     try {
88171       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
88172     } catch (std::out_of_range& e) {
88173       {
88174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88175       };
88176     } catch (std::exception& e) {
88177       {
88178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88179       };
88180     } catch (Dali::DaliException e) {
88181       {
88182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88183       };
88184     } catch (...) {
88185       {
88186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88187       };
88188     }
88189   }
88190
88191   jresult = (void *)result;
88192   return jresult;
88193 }
88194
88195
88196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
88197   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88198   unsigned int arg2 ;
88199
88200   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88201   arg2 = (unsigned int)jarg2;
88202   if (arg1) (arg1)->first = arg2;
88203 }
88204
88205
88206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
88207   unsigned int jresult ;
88208   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88209   unsigned int result;
88210
88211   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88212   result = (unsigned int) ((arg1)->first);
88213   jresult = result;
88214   return jresult;
88215 }
88216
88217
88218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
88219   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88220   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
88221
88222   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88223   arg2 = (Dali::Actor *)jarg2;
88224   if (arg1) (arg1)->second = *arg2;
88225 }
88226
88227
88228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
88229   void * jresult ;
88230   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88231   Dali::Actor *result = 0 ;
88232
88233   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88234   result = (Dali::Actor *)& ((arg1)->second);
88235   jresult = (void *)result;
88236   return jresult;
88237 }
88238
88239
88240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
88241   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88242
88243   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88244   {
88245     try {
88246       delete arg1;
88247     } catch (std::out_of_range& e) {
88248       {
88249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88250       };
88251     } catch (std::exception& e) {
88252       {
88253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88254       };
88255     } catch (Dali::DaliException e) {
88256       {
88257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88258       };
88259     } catch (...) {
88260       {
88261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88262       };
88263     }
88264   }
88265
88266 }
88267
88268
88269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
88270   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88271
88272   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88273   {
88274     try {
88275       (arg1)->clear();
88276     } catch (std::out_of_range& e) {
88277       {
88278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88279       };
88280     } catch (std::exception& e) {
88281       {
88282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88283       };
88284     } catch (Dali::DaliException e) {
88285       {
88286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88287       };
88288     } catch (...) {
88289       {
88290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88291       };
88292     }
88293   }
88294
88295 }
88296
88297
88298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
88299   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88300   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
88301
88302   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88303   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
88304   if (!arg2) {
88305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88306     return ;
88307   }
88308   {
88309     try {
88310       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
88311     } catch (std::out_of_range& e) {
88312       {
88313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88314       };
88315     } catch (std::exception& e) {
88316       {
88317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88318       };
88319     } catch (Dali::DaliException e) {
88320       {
88321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88322       };
88323     } catch (...) {
88324       {
88325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88326       };
88327     }
88328   }
88329
88330 }
88331
88332
88333 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
88334   unsigned long jresult ;
88335   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88336   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88337
88338   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88339   {
88340     try {
88341       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
88342     } catch (std::out_of_range& e) {
88343       {
88344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88345       };
88346     } catch (std::exception& e) {
88347       {
88348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88349       };
88350     } catch (Dali::DaliException e) {
88351       {
88352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88353       };
88354     } catch (...) {
88355       {
88356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88357       };
88358     }
88359   }
88360
88361   jresult = (unsigned long)result;
88362   return jresult;
88363 }
88364
88365
88366 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
88367   unsigned long jresult ;
88368   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88369   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88370
88371   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88372   {
88373     try {
88374       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
88375     } catch (std::out_of_range& e) {
88376       {
88377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88378       };
88379     } catch (std::exception& e) {
88380       {
88381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88382       };
88383     } catch (Dali::DaliException e) {
88384       {
88385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88386       };
88387     } catch (...) {
88388       {
88389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88390       };
88391     }
88392   }
88393
88394   jresult = (unsigned long)result;
88395   return jresult;
88396 }
88397
88398
88399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
88400   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88401   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
88402
88403   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88404   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
88405   {
88406     try {
88407       (arg1)->reserve(arg2);
88408     } catch (std::out_of_range& e) {
88409       {
88410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88411       };
88412     } catch (std::exception& e) {
88413       {
88414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88415       };
88416     } catch (Dali::DaliException e) {
88417       {
88418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88419       };
88420     } catch (...) {
88421       {
88422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88423       };
88424     }
88425   }
88426
88427 }
88428
88429
88430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
88431   void * jresult ;
88432   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88433
88434   {
88435     try {
88436       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
88437     } catch (std::out_of_range& e) {
88438       {
88439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88440       };
88441     } catch (std::exception& e) {
88442       {
88443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88444       };
88445     } catch (Dali::DaliException e) {
88446       {
88447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88448       };
88449     } catch (...) {
88450       {
88451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88452       };
88453     }
88454   }
88455
88456   jresult = (void *)result;
88457   return jresult;
88458 }
88459
88460
88461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
88462   void * jresult ;
88463   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
88464   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88465
88466   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88467   if (!arg1) {
88468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88469     return 0;
88470   }
88471   {
88472     try {
88473       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);
88474     } catch (std::out_of_range& e) {
88475       {
88476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88477       };
88478     } catch (std::exception& e) {
88479       {
88480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88481       };
88482     } catch (Dali::DaliException e) {
88483       {
88484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88485       };
88486     } catch (...) {
88487       {
88488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88489       };
88490     }
88491   }
88492
88493   jresult = (void *)result;
88494   return jresult;
88495 }
88496
88497
88498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
88499   void * jresult ;
88500   int arg1 ;
88501   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88502
88503   arg1 = (int)jarg1;
88504   {
88505     try {
88506       try {
88507         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);
88508       }
88509       catch(std::out_of_range &_e) {
88510         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88511         return 0;
88512       }
88513
88514     } catch (std::out_of_range& e) {
88515       {
88516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88517       };
88518     } catch (std::exception& e) {
88519       {
88520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88521       };
88522     } catch (Dali::DaliException e) {
88523       {
88524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88525       };
88526     } catch (...) {
88527       {
88528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88529       };
88530     }
88531   }
88532
88533   jresult = (void *)result;
88534   return jresult;
88535 }
88536
88537
88538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
88539   void * jresult ;
88540   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88541   int arg2 ;
88542   std::pair< unsigned int,Dali::Actor > result;
88543
88544   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88545   arg2 = (int)jarg2;
88546   {
88547     try {
88548       try {
88549         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
88550       }
88551       catch(std::out_of_range &_e) {
88552         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88553         return 0;
88554       }
88555
88556     } catch (std::out_of_range& e) {
88557       {
88558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88559       };
88560     } catch (std::exception& e) {
88561       {
88562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88563       };
88564     } catch (Dali::DaliException e) {
88565       {
88566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88567       };
88568     } catch (...) {
88569       {
88570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88571       };
88572     }
88573   }
88574
88575   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
88576   return jresult;
88577 }
88578
88579
88580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
88581   void * jresult ;
88582   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88583   int arg2 ;
88584   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88585
88586   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88587   arg2 = (int)jarg2;
88588   {
88589     try {
88590       try {
88591         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
88592       }
88593       catch(std::out_of_range &_e) {
88594         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88595         return 0;
88596       }
88597
88598     } catch (std::out_of_range& e) {
88599       {
88600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88601       };
88602     } catch (std::exception& e) {
88603       {
88604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88605       };
88606     } catch (Dali::DaliException e) {
88607       {
88608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88609       };
88610     } catch (...) {
88611       {
88612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88613       };
88614     }
88615   }
88616
88617   jresult = (void *)result;
88618   return jresult;
88619 }
88620
88621
88622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88623   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88624   int arg2 ;
88625   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88626
88627   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88628   arg2 = (int)jarg2;
88629   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88630   if (!arg3) {
88631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88632     return ;
88633   }
88634   {
88635     try {
88636       try {
88637         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(arg1,arg2,(std::pair< unsigned int,Dali::Actor > const &)*arg3);
88638       }
88639       catch(std::out_of_range &_e) {
88640         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88641         return ;
88642       }
88643
88644     } catch (std::out_of_range& e) {
88645       {
88646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88647       };
88648     } catch (std::exception& e) {
88649       {
88650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88651       };
88652     } catch (Dali::DaliException e) {
88653       {
88654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88655       };
88656     } catch (...) {
88657       {
88658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88659       };
88660     }
88661   }
88662
88663 }
88664
88665
88666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
88667   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88668   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
88669
88670   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88671   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
88672   if (!arg2) {
88673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88674     return ;
88675   }
88676   {
88677     try {
88678       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);
88679     } catch (std::out_of_range& e) {
88680       {
88681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88682       };
88683     } catch (std::exception& e) {
88684       {
88685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88686       };
88687     } catch (Dali::DaliException e) {
88688       {
88689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88690       };
88691     } catch (...) {
88692       {
88693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88694       };
88695     }
88696   }
88697
88698 }
88699
88700
88701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88702   void * jresult ;
88703   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88704   int arg2 ;
88705   int arg3 ;
88706   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88707
88708   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88709   arg2 = (int)jarg2;
88710   arg3 = (int)jarg3;
88711   {
88712     try {
88713       try {
88714         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);
88715       }
88716       catch(std::out_of_range &_e) {
88717         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88718         return 0;
88719       }
88720       catch(std::invalid_argument &_e) {
88721         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88722         return 0;
88723       }
88724
88725     } catch (std::out_of_range& e) {
88726       {
88727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88728       };
88729     } catch (std::exception& e) {
88730       {
88731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88732       };
88733     } catch (Dali::DaliException e) {
88734       {
88735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88736       };
88737     } catch (...) {
88738       {
88739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88740       };
88741     }
88742   }
88743
88744   jresult = (void *)result;
88745   return jresult;
88746 }
88747
88748
88749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88750   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88751   int arg2 ;
88752   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88753
88754   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88755   arg2 = (int)jarg2;
88756   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88757   if (!arg3) {
88758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88759     return ;
88760   }
88761   {
88762     try {
88763       try {
88764         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);
88765       }
88766       catch(std::out_of_range &_e) {
88767         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88768         return ;
88769       }
88770
88771     } catch (std::out_of_range& e) {
88772       {
88773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88774       };
88775     } catch (std::exception& e) {
88776       {
88777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88778       };
88779     } catch (Dali::DaliException e) {
88780       {
88781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88782       };
88783     } catch (...) {
88784       {
88785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88786       };
88787     }
88788   }
88789
88790 }
88791
88792
88793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88794   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88795   int arg2 ;
88796   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88797
88798   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88799   arg2 = (int)jarg2;
88800   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88801   if (!arg3) {
88802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88803     return ;
88804   }
88805   {
88806     try {
88807       try {
88808         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);
88809       }
88810       catch(std::out_of_range &_e) {
88811         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88812         return ;
88813       }
88814
88815     } catch (std::out_of_range& e) {
88816       {
88817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88818       };
88819     } catch (std::exception& e) {
88820       {
88821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88822       };
88823     } catch (Dali::DaliException e) {
88824       {
88825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88826       };
88827     } catch (...) {
88828       {
88829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88830       };
88831     }
88832   }
88833
88834 }
88835
88836
88837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
88838   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88839   int arg2 ;
88840
88841   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88842   arg2 = (int)jarg2;
88843   {
88844     try {
88845       try {
88846         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
88847       }
88848       catch(std::out_of_range &_e) {
88849         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88850         return ;
88851       }
88852
88853     } catch (std::out_of_range& e) {
88854       {
88855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88856       };
88857     } catch (std::exception& e) {
88858       {
88859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88860       };
88861     } catch (Dali::DaliException e) {
88862       {
88863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88864       };
88865     } catch (...) {
88866       {
88867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88868       };
88869     }
88870   }
88871
88872 }
88873
88874
88875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88876   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88877   int arg2 ;
88878   int arg3 ;
88879
88880   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88881   arg2 = (int)jarg2;
88882   arg3 = (int)jarg3;
88883   {
88884     try {
88885       try {
88886         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
88887       }
88888       catch(std::out_of_range &_e) {
88889         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88890         return ;
88891       }
88892       catch(std::invalid_argument &_e) {
88893         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88894         return ;
88895       }
88896
88897     } catch (std::out_of_range& e) {
88898       {
88899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88900       };
88901     } catch (std::exception& e) {
88902       {
88903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88904       };
88905     } catch (Dali::DaliException e) {
88906       {
88907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88908       };
88909     } catch (...) {
88910       {
88911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88912       };
88913     }
88914   }
88915
88916 }
88917
88918
88919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
88920   void * jresult ;
88921   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88922   int arg2 ;
88923   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88924
88925   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88926   if (!arg1) {
88927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88928     return 0;
88929   }
88930   arg2 = (int)jarg2;
88931   {
88932     try {
88933       try {
88934         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);
88935       }
88936       catch(std::out_of_range &_e) {
88937         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88938         return 0;
88939       }
88940
88941     } catch (std::out_of_range& e) {
88942       {
88943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88944       };
88945     } catch (std::exception& e) {
88946       {
88947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88948       };
88949     } catch (Dali::DaliException e) {
88950       {
88951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88952       };
88953     } catch (...) {
88954       {
88955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88956       };
88957     }
88958   }
88959
88960   jresult = (void *)result;
88961   return jresult;
88962 }
88963
88964
88965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
88966   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88967
88968   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88969   {
88970     try {
88971       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
88972     } catch (std::out_of_range& e) {
88973       {
88974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88975       };
88976     } catch (std::exception& e) {
88977       {
88978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88979       };
88980     } catch (Dali::DaliException e) {
88981       {
88982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88983       };
88984     } catch (...) {
88985       {
88986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88987       };
88988     }
88989   }
88990
88991 }
88992
88993
88994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88995   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88996   int arg2 ;
88997   int arg3 ;
88998
88999   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89000   arg2 = (int)jarg2;
89001   arg3 = (int)jarg3;
89002   {
89003     try {
89004       try {
89005         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89006       }
89007       catch(std::out_of_range &_e) {
89008         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89009         return ;
89010       }
89011       catch(std::invalid_argument &_e) {
89012         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89013         return ;
89014       }
89015
89016     } catch (std::out_of_range& e) {
89017       {
89018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89019       };
89020     } catch (std::exception& e) {
89021       {
89022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89023       };
89024     } catch (Dali::DaliException e) {
89025       {
89026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89027       };
89028     } catch (...) {
89029       {
89030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89031       };
89032     }
89033   }
89034
89035 }
89036
89037
89038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89039   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89040   int arg2 ;
89041   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
89042
89043   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89044   arg2 = (int)jarg2;
89045   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
89046   if (!arg3) {
89047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89048     return ;
89049   }
89050   {
89051     try {
89052       try {
89053         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);
89054       }
89055       catch(std::out_of_range &_e) {
89056         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89057         return ;
89058       }
89059
89060     } catch (std::out_of_range& e) {
89061       {
89062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89063       };
89064     } catch (std::exception& e) {
89065       {
89066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89067       };
89068     } catch (Dali::DaliException e) {
89069       {
89070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89071       };
89072     } catch (...) {
89073       {
89074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89075       };
89076     }
89077   }
89078
89079 }
89080
89081
89082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
89083   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89084
89085   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89086   {
89087     try {
89088       delete arg1;
89089     } catch (std::out_of_range& e) {
89090       {
89091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89092       };
89093     } catch (std::exception& e) {
89094       {
89095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89096       };
89097     } catch (Dali::DaliException e) {
89098       {
89099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89100       };
89101     } catch (...) {
89102       {
89103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89104       };
89105     }
89106   }
89107
89108 }
89109
89110
89111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
89112   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89113
89114   arg1 = (std::vector< Dali::Actor > *)jarg1;
89115   {
89116     try {
89117       (arg1)->clear();
89118     } catch (std::out_of_range& e) {
89119       {
89120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89121       };
89122     } catch (std::exception& e) {
89123       {
89124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89125       };
89126     } catch (Dali::DaliException e) {
89127       {
89128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89129       };
89130     } catch (...) {
89131       {
89132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89133       };
89134     }
89135   }
89136
89137 }
89138
89139
89140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
89141   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89142   Dali::Actor *arg2 = 0 ;
89143
89144   arg1 = (std::vector< Dali::Actor > *)jarg1;
89145   arg2 = (Dali::Actor *)jarg2;
89146   if (!arg2) {
89147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89148     return ;
89149   }
89150   {
89151     try {
89152       (arg1)->push_back((Dali::Actor const &)*arg2);
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 unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
89176   unsigned long jresult ;
89177   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89178   std::vector< Dali::Actor >::size_type result;
89179
89180   arg1 = (std::vector< Dali::Actor > *)jarg1;
89181   {
89182     try {
89183       result = ((std::vector< Dali::Actor > const *)arg1)->size();
89184     } catch (std::out_of_range& e) {
89185       {
89186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89187       };
89188     } catch (std::exception& e) {
89189       {
89190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89191       };
89192     } catch (Dali::DaliException e) {
89193       {
89194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89195       };
89196     } catch (...) {
89197       {
89198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89199       };
89200     }
89201   }
89202
89203   jresult = (unsigned long)result;
89204   return jresult;
89205 }
89206
89207
89208 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
89209   unsigned long jresult ;
89210   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89211   std::vector< Dali::Actor >::size_type result;
89212
89213   arg1 = (std::vector< Dali::Actor > *)jarg1;
89214   {
89215     try {
89216       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
89217     } catch (std::out_of_range& e) {
89218       {
89219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89220       };
89221     } catch (std::exception& e) {
89222       {
89223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89224       };
89225     } catch (Dali::DaliException e) {
89226       {
89227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89228       };
89229     } catch (...) {
89230       {
89231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89232       };
89233     }
89234   }
89235
89236   jresult = (unsigned long)result;
89237   return jresult;
89238 }
89239
89240
89241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
89242   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89243   std::vector< Dali::Actor >::size_type arg2 ;
89244
89245   arg1 = (std::vector< Dali::Actor > *)jarg1;
89246   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
89247   {
89248     try {
89249       (arg1)->reserve(arg2);
89250     } catch (std::out_of_range& e) {
89251       {
89252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89253       };
89254     } catch (std::exception& e) {
89255       {
89256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89257       };
89258     } catch (Dali::DaliException e) {
89259       {
89260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89261       };
89262     } catch (...) {
89263       {
89264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89265       };
89266     }
89267   }
89268
89269 }
89270
89271
89272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
89273   void * jresult ;
89274   std::vector< Dali::Actor > *result = 0 ;
89275
89276   {
89277     try {
89278       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
89279     } catch (std::out_of_range& e) {
89280       {
89281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89282       };
89283     } catch (std::exception& e) {
89284       {
89285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89286       };
89287     } catch (Dali::DaliException e) {
89288       {
89289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89290       };
89291     } catch (...) {
89292       {
89293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89294       };
89295     }
89296   }
89297
89298   jresult = (void *)result;
89299   return jresult;
89300 }
89301
89302
89303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
89304   void * jresult ;
89305   std::vector< Dali::Actor > *arg1 = 0 ;
89306   std::vector< Dali::Actor > *result = 0 ;
89307
89308   arg1 = (std::vector< Dali::Actor > *)jarg1;
89309   if (!arg1) {
89310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89311     return 0;
89312   }
89313   {
89314     try {
89315       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
89316     } catch (std::out_of_range& e) {
89317       {
89318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89319       };
89320     } catch (std::exception& e) {
89321       {
89322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89323       };
89324     } catch (Dali::DaliException e) {
89325       {
89326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89327       };
89328     } catch (...) {
89329       {
89330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89331       };
89332     }
89333   }
89334
89335   jresult = (void *)result;
89336   return jresult;
89337 }
89338
89339
89340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
89341   void * jresult ;
89342   int arg1 ;
89343   std::vector< Dali::Actor > *result = 0 ;
89344
89345   arg1 = (int)jarg1;
89346   {
89347     try {
89348       try {
89349         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
89350       }
89351       catch(std::out_of_range &_e) {
89352         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89353         return 0;
89354       }
89355
89356     } catch (std::out_of_range& e) {
89357       {
89358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89359       };
89360     } catch (std::exception& e) {
89361       {
89362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89363       };
89364     } catch (Dali::DaliException e) {
89365       {
89366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89367       };
89368     } catch (...) {
89369       {
89370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89371       };
89372     }
89373   }
89374
89375   jresult = (void *)result;
89376   return jresult;
89377 }
89378
89379
89380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
89381   void * jresult ;
89382   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89383   int arg2 ;
89384   Dali::Actor result;
89385
89386   arg1 = (std::vector< Dali::Actor > *)jarg1;
89387   arg2 = (int)jarg2;
89388   {
89389     try {
89390       try {
89391         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
89392       }
89393       catch(std::out_of_range &_e) {
89394         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89395         return 0;
89396       }
89397
89398     } catch (std::out_of_range& e) {
89399       {
89400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89401       };
89402     } catch (std::exception& e) {
89403       {
89404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89405       };
89406     } catch (Dali::DaliException e) {
89407       {
89408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89409       };
89410     } catch (...) {
89411       {
89412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89413       };
89414     }
89415   }
89416
89417   jresult = new Dali::Actor((const Dali::Actor &)result);
89418   return jresult;
89419 }
89420
89421
89422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
89423   void * jresult ;
89424   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89425   int arg2 ;
89426   Dali::Actor *result = 0 ;
89427
89428   arg1 = (std::vector< Dali::Actor > *)jarg1;
89429   arg2 = (int)jarg2;
89430   {
89431     try {
89432       try {
89433         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
89434       }
89435       catch(std::out_of_range &_e) {
89436         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89437         return 0;
89438       }
89439
89440     } catch (std::out_of_range& e) {
89441       {
89442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89443       };
89444     } catch (std::exception& e) {
89445       {
89446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89447       };
89448     } catch (Dali::DaliException e) {
89449       {
89450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89451       };
89452     } catch (...) {
89453       {
89454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89455       };
89456     }
89457   }
89458
89459   jresult = (void *)result;
89460   return jresult;
89461 }
89462
89463
89464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
89465   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89466   int arg2 ;
89467   Dali::Actor *arg3 = 0 ;
89468
89469   arg1 = (std::vector< Dali::Actor > *)jarg1;
89470   arg2 = (int)jarg2;
89471   arg3 = (Dali::Actor *)jarg3;
89472   if (!arg3) {
89473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89474     return ;
89475   }
89476   {
89477     try {
89478       try {
89479         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
89480       }
89481       catch(std::out_of_range &_e) {
89482         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89483         return ;
89484       }
89485
89486     } catch (std::out_of_range& e) {
89487       {
89488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89489       };
89490     } catch (std::exception& e) {
89491       {
89492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89493       };
89494     } catch (Dali::DaliException e) {
89495       {
89496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89497       };
89498     } catch (...) {
89499       {
89500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89501       };
89502     }
89503   }
89504
89505 }
89506
89507
89508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
89509   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89510   std::vector< Dali::Actor > *arg2 = 0 ;
89511
89512   arg1 = (std::vector< Dali::Actor > *)jarg1;
89513   arg2 = (std::vector< Dali::Actor > *)jarg2;
89514   if (!arg2) {
89515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89516     return ;
89517   }
89518   {
89519     try {
89520       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
89521     } catch (std::out_of_range& e) {
89522       {
89523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89524       };
89525     } catch (std::exception& e) {
89526       {
89527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89528       };
89529     } catch (Dali::DaliException e) {
89530       {
89531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89532       };
89533     } catch (...) {
89534       {
89535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89536       };
89537     }
89538   }
89539
89540 }
89541
89542
89543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
89544   void * jresult ;
89545   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89546   int arg2 ;
89547   int arg3 ;
89548   std::vector< Dali::Actor > *result = 0 ;
89549
89550   arg1 = (std::vector< Dali::Actor > *)jarg1;
89551   arg2 = (int)jarg2;
89552   arg3 = (int)jarg3;
89553   {
89554     try {
89555       try {
89556         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
89557       }
89558       catch(std::out_of_range &_e) {
89559         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89560         return 0;
89561       }
89562       catch(std::invalid_argument &_e) {
89563         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89564         return 0;
89565       }
89566
89567     } catch (std::out_of_range& e) {
89568       {
89569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89570       };
89571     } catch (std::exception& e) {
89572       {
89573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89574       };
89575     } catch (Dali::DaliException e) {
89576       {
89577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89578       };
89579     } catch (...) {
89580       {
89581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89582       };
89583     }
89584   }
89585
89586   jresult = (void *)result;
89587   return jresult;
89588 }
89589
89590
89591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
89592   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89593   int arg2 ;
89594   Dali::Actor *arg3 = 0 ;
89595
89596   arg1 = (std::vector< Dali::Actor > *)jarg1;
89597   arg2 = (int)jarg2;
89598   arg3 = (Dali::Actor *)jarg3;
89599   if (!arg3) {
89600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89601     return ;
89602   }
89603   {
89604     try {
89605       try {
89606         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
89607       }
89608       catch(std::out_of_range &_e) {
89609         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89610         return ;
89611       }
89612
89613     } catch (std::out_of_range& e) {
89614       {
89615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89616       };
89617     } catch (std::exception& e) {
89618       {
89619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89620       };
89621     } catch (Dali::DaliException e) {
89622       {
89623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89624       };
89625     } catch (...) {
89626       {
89627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89628       };
89629     }
89630   }
89631
89632 }
89633
89634
89635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89636   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89637   int arg2 ;
89638   std::vector< Dali::Actor > *arg3 = 0 ;
89639
89640   arg1 = (std::vector< Dali::Actor > *)jarg1;
89641   arg2 = (int)jarg2;
89642   arg3 = (std::vector< Dali::Actor > *)jarg3;
89643   if (!arg3) {
89644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89645     return ;
89646   }
89647   {
89648     try {
89649       try {
89650         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89651       }
89652       catch(std::out_of_range &_e) {
89653         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89654         return ;
89655       }
89656
89657     } catch (std::out_of_range& e) {
89658       {
89659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89660       };
89661     } catch (std::exception& e) {
89662       {
89663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89664       };
89665     } catch (Dali::DaliException e) {
89666       {
89667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89668       };
89669     } catch (...) {
89670       {
89671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89672       };
89673     }
89674   }
89675
89676 }
89677
89678
89679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
89680   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89681   int arg2 ;
89682
89683   arg1 = (std::vector< Dali::Actor > *)jarg1;
89684   arg2 = (int)jarg2;
89685   {
89686     try {
89687       try {
89688         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
89689       }
89690       catch(std::out_of_range &_e) {
89691         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89692         return ;
89693       }
89694
89695     } catch (std::out_of_range& e) {
89696       {
89697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89698       };
89699     } catch (std::exception& e) {
89700       {
89701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89702       };
89703     } catch (Dali::DaliException e) {
89704       {
89705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89706       };
89707     } catch (...) {
89708       {
89709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89710       };
89711     }
89712   }
89713
89714 }
89715
89716
89717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89718   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89719   int arg2 ;
89720   int arg3 ;
89721
89722   arg1 = (std::vector< Dali::Actor > *)jarg1;
89723   arg2 = (int)jarg2;
89724   arg3 = (int)jarg3;
89725   {
89726     try {
89727       try {
89728         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
89729       }
89730       catch(std::out_of_range &_e) {
89731         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89732         return ;
89733       }
89734       catch(std::invalid_argument &_e) {
89735         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89736         return ;
89737       }
89738
89739     } catch (std::out_of_range& e) {
89740       {
89741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89742       };
89743     } catch (std::exception& e) {
89744       {
89745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89746       };
89747     } catch (Dali::DaliException e) {
89748       {
89749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89750       };
89751     } catch (...) {
89752       {
89753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89754       };
89755     }
89756   }
89757
89758 }
89759
89760
89761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
89762   void * jresult ;
89763   Dali::Actor *arg1 = 0 ;
89764   int arg2 ;
89765   std::vector< Dali::Actor > *result = 0 ;
89766
89767   arg1 = (Dali::Actor *)jarg1;
89768   if (!arg1) {
89769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89770     return 0;
89771   }
89772   arg2 = (int)jarg2;
89773   {
89774     try {
89775       try {
89776         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
89777       }
89778       catch(std::out_of_range &_e) {
89779         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89780         return 0;
89781       }
89782
89783     } catch (std::out_of_range& e) {
89784       {
89785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89786       };
89787     } catch (std::exception& e) {
89788       {
89789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89790       };
89791     } catch (Dali::DaliException e) {
89792       {
89793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89794       };
89795     } catch (...) {
89796       {
89797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89798       };
89799     }
89800   }
89801
89802   jresult = (void *)result;
89803   return jresult;
89804 }
89805
89806
89807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
89808   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89809
89810   arg1 = (std::vector< Dali::Actor > *)jarg1;
89811   {
89812     try {
89813       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
89814     } catch (std::out_of_range& e) {
89815       {
89816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89817       };
89818     } catch (std::exception& e) {
89819       {
89820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89821       };
89822     } catch (Dali::DaliException e) {
89823       {
89824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89825       };
89826     } catch (...) {
89827       {
89828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89829       };
89830     }
89831   }
89832
89833 }
89834
89835
89836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89837   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89838   int arg2 ;
89839   int arg3 ;
89840
89841   arg1 = (std::vector< Dali::Actor > *)jarg1;
89842   arg2 = (int)jarg2;
89843   arg3 = (int)jarg3;
89844   {
89845     try {
89846       try {
89847         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89848       }
89849       catch(std::out_of_range &_e) {
89850         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89851         return ;
89852       }
89853       catch(std::invalid_argument &_e) {
89854         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89855         return ;
89856       }
89857
89858     } catch (std::out_of_range& e) {
89859       {
89860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89861       };
89862     } catch (std::exception& e) {
89863       {
89864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89865       };
89866     } catch (Dali::DaliException e) {
89867       {
89868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89869       };
89870     } catch (...) {
89871       {
89872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89873       };
89874     }
89875   }
89876
89877 }
89878
89879
89880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89881   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89882   int arg2 ;
89883   std::vector< Dali::Actor > *arg3 = 0 ;
89884
89885   arg1 = (std::vector< Dali::Actor > *)jarg1;
89886   arg2 = (int)jarg2;
89887   arg3 = (std::vector< Dali::Actor > *)jarg3;
89888   if (!arg3) {
89889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89890     return ;
89891   }
89892   {
89893     try {
89894       try {
89895         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89896       }
89897       catch(std::out_of_range &_e) {
89898         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89899         return ;
89900       }
89901
89902     } catch (std::out_of_range& e) {
89903       {
89904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89905       };
89906     } catch (std::exception& e) {
89907       {
89908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89909       };
89910     } catch (Dali::DaliException e) {
89911       {
89912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89913       };
89914     } catch (...) {
89915       {
89916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89917       };
89918     }
89919   }
89920
89921 }
89922
89923
89924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
89925   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89926
89927   arg1 = (std::vector< Dali::Actor > *)jarg1;
89928   {
89929     try {
89930       delete arg1;
89931     } catch (std::out_of_range& e) {
89932       {
89933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89934       };
89935     } catch (std::exception& e) {
89936       {
89937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89938       };
89939     } catch (Dali::DaliException e) {
89940       {
89941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89942       };
89943     } catch (...) {
89944       {
89945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89946       };
89947     }
89948   }
89949
89950 }
89951
89952
89953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
89954   unsigned int jresult ;
89955   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89956   bool result;
89957
89958   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89959   {
89960     try {
89961       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89962     } catch (std::out_of_range& e) {
89963       {
89964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89965       };
89966     } catch (std::exception& e) {
89967       {
89968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89969       };
89970     } catch (Dali::DaliException e) {
89971       {
89972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89973       };
89974     } catch (...) {
89975       {
89976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89977       };
89978     }
89979   }
89980
89981   jresult = result;
89982   return jresult;
89983 }
89984
89985
89986 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
89987   unsigned long jresult ;
89988   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89989   std::size_t result;
89990
89991   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89992   {
89993     try {
89994       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89995     } catch (std::out_of_range& e) {
89996       {
89997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89998       };
89999     } catch (std::exception& e) {
90000       {
90001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90002       };
90003     } catch (Dali::DaliException e) {
90004       {
90005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90006       };
90007     } catch (...) {
90008       {
90009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90010       };
90011     }
90012   }
90013
90014   jresult = (unsigned long)result;
90015   return jresult;
90016 }
90017
90018
90019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
90020   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90021   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90022
90023   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90024   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90025   {
90026     try {
90027       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
90028     } catch (std::out_of_range& e) {
90029       {
90030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90031       };
90032     } catch (std::exception& e) {
90033       {
90034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90035       };
90036     } catch (Dali::DaliException e) {
90037       {
90038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90039       };
90040     } catch (...) {
90041       {
90042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90043       };
90044     }
90045   }
90046
90047 }
90048
90049
90050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
90051   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90052   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90053
90054   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90055   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90056   {
90057     try {
90058       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
90059     } catch (std::out_of_range& e) {
90060       {
90061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90062       };
90063     } catch (std::exception& e) {
90064       {
90065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90066       };
90067     } catch (Dali::DaliException e) {
90068       {
90069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90070       };
90071     } catch (...) {
90072       {
90073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90074       };
90075     }
90076   }
90077
90078 }
90079
90080
90081 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
90082   unsigned int jresult ;
90083   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90084   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
90085   bool result;
90086
90087   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90088   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
90089   if (!arg2) {
90090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
90091     return 0;
90092   }
90093   {
90094     try {
90095       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
90096     } catch (std::out_of_range& e) {
90097       {
90098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90099       };
90100     } catch (std::exception& e) {
90101       {
90102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90103       };
90104     } catch (Dali::DaliException e) {
90105       {
90106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90107       };
90108     } catch (...) {
90109       {
90110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90111       };
90112     }
90113   }
90114
90115   jresult = result;
90116   return jresult;
90117 }
90118
90119
90120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
90121   void * jresult ;
90122   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
90123
90124   {
90125     try {
90126       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
90127     } catch (std::out_of_range& e) {
90128       {
90129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90130       };
90131     } catch (std::exception& e) {
90132       {
90133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90134       };
90135     } catch (Dali::DaliException e) {
90136       {
90137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90138       };
90139     } catch (...) {
90140       {
90141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90142       };
90143     }
90144   }
90145
90146   jresult = (void *)result;
90147   return jresult;
90148 }
90149
90150
90151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
90152   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90153
90154   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90155   {
90156     try {
90157       delete arg1;
90158     } catch (std::out_of_range& e) {
90159       {
90160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90161       };
90162     } catch (std::exception& e) {
90163       {
90164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90165       };
90166     } catch (Dali::DaliException e) {
90167       {
90168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90169       };
90170     } catch (...) {
90171       {
90172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90173       };
90174     }
90175   }
90176
90177 }
90178
90179
90180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
90181   unsigned int jresult ;
90182   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90183   bool result;
90184
90185   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90186   {
90187     try {
90188       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);
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 unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
90214   unsigned long jresult ;
90215   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90216   std::size_t result;
90217
90218   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90219   {
90220     try {
90221       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);
90222     } catch (std::out_of_range& e) {
90223       {
90224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90225       };
90226     } catch (std::exception& e) {
90227       {
90228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90229       };
90230     } catch (Dali::DaliException e) {
90231       {
90232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90233       };
90234     } catch (...) {
90235       {
90236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90237       };
90238     }
90239   }
90240
90241   jresult = (unsigned long)result;
90242   return jresult;
90243 }
90244
90245
90246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
90247   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90248   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90249
90250   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90251   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90252   {
90253     try {
90254       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
90255     } catch (std::out_of_range& e) {
90256       {
90257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90258       };
90259     } catch (std::exception& e) {
90260       {
90261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90262       };
90263     } catch (Dali::DaliException e) {
90264       {
90265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90266       };
90267     } catch (...) {
90268       {
90269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90270       };
90271     }
90272   }
90273
90274 }
90275
90276
90277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
90278   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90279   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90280
90281   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90282   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90283   {
90284     try {
90285       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
90286     } catch (std::out_of_range& e) {
90287       {
90288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90289       };
90290     } catch (std::exception& e) {
90291       {
90292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90293       };
90294     } catch (Dali::DaliException e) {
90295       {
90296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90297       };
90298     } catch (...) {
90299       {
90300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90301       };
90302     }
90303   }
90304
90305 }
90306
90307
90308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90309   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90310   Dali::Actor arg2 ;
90311   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
90312   Dali::Actor *argp2 ;
90313
90314   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90315   argp2 = (Dali::Actor *)jarg2;
90316   if (!argp2) {
90317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90318     return ;
90319   }
90320   arg2 = *argp2;
90321   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
90322   {
90323     try {
90324       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
90325     } catch (std::out_of_range& e) {
90326       {
90327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90328       };
90329     } catch (std::exception& e) {
90330       {
90331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90332       };
90333     } catch (Dali::DaliException e) {
90334       {
90335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90336       };
90337     } catch (...) {
90338       {
90339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90340       };
90341     }
90342   }
90343
90344 }
90345
90346
90347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
90348   void * jresult ;
90349   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
90350
90351   {
90352     try {
90353       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
90354     } catch (std::out_of_range& e) {
90355       {
90356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90357       };
90358     } catch (std::exception& e) {
90359       {
90360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90361       };
90362     } catch (Dali::DaliException e) {
90363       {
90364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90365       };
90366     } catch (...) {
90367       {
90368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90369       };
90370     }
90371   }
90372
90373   jresult = (void *)result;
90374   return jresult;
90375 }
90376
90377
90378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
90379   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90380
90381   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90382   {
90383     try {
90384       delete arg1;
90385     } catch (std::out_of_range& e) {
90386       {
90387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90388       };
90389     } catch (std::exception& e) {
90390       {
90391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90392       };
90393     } catch (Dali::DaliException e) {
90394       {
90395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90396       };
90397     } catch (...) {
90398       {
90399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90400       };
90401     }
90402   }
90403
90404 }
90405
90406
90407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
90408   unsigned int jresult ;
90409   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90410   bool result;
90411
90412   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90413   {
90414     try {
90415       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90416     } catch (std::out_of_range& e) {
90417       {
90418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90419       };
90420     } catch (std::exception& e) {
90421       {
90422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90423       };
90424     } catch (Dali::DaliException e) {
90425       {
90426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90427       };
90428     } catch (...) {
90429       {
90430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90431       };
90432     }
90433   }
90434
90435   jresult = result;
90436   return jresult;
90437 }
90438
90439
90440 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
90441   unsigned long jresult ;
90442   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90443   std::size_t result;
90444
90445   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90446   {
90447     try {
90448       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90449     } catch (std::out_of_range& e) {
90450       {
90451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90452       };
90453     } catch (std::exception& e) {
90454       {
90455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90456       };
90457     } catch (Dali::DaliException e) {
90458       {
90459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90460       };
90461     } catch (...) {
90462       {
90463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90464       };
90465     }
90466   }
90467
90468   jresult = (unsigned long)result;
90469   return jresult;
90470 }
90471
90472
90473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
90474   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90475   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90476
90477   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90478   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90479   {
90480     try {
90481       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
90482     } catch (std::out_of_range& e) {
90483       {
90484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90485       };
90486     } catch (std::exception& e) {
90487       {
90488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90489       };
90490     } catch (Dali::DaliException e) {
90491       {
90492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90493       };
90494     } catch (...) {
90495       {
90496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90497       };
90498     }
90499   }
90500
90501 }
90502
90503
90504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90505   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90506   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90507
90508   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90509   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90510   {
90511     try {
90512       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
90513     } catch (std::out_of_range& e) {
90514       {
90515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90516       };
90517     } catch (std::exception& e) {
90518       {
90519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90520       };
90521     } catch (Dali::DaliException e) {
90522       {
90523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90524       };
90525     } catch (...) {
90526       {
90527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90528       };
90529     }
90530   }
90531
90532 }
90533
90534
90535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90536   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90537   Dali::Actor arg2 ;
90538   Dali::Actor arg3 ;
90539   Dali::Actor *argp2 ;
90540   Dali::Actor *argp3 ;
90541
90542   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90543   argp2 = (Dali::Actor *)jarg2;
90544   if (!argp2) {
90545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90546     return ;
90547   }
90548   arg2 = *argp2;
90549   argp3 = (Dali::Actor *)jarg3;
90550   if (!argp3) {
90551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90552     return ;
90553   }
90554   arg3 = *argp3;
90555   {
90556     try {
90557       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
90558     } catch (std::out_of_range& e) {
90559       {
90560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90561       };
90562     } catch (std::exception& e) {
90563       {
90564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90565       };
90566     } catch (Dali::DaliException e) {
90567       {
90568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90569       };
90570     } catch (...) {
90571       {
90572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90573       };
90574     }
90575   }
90576
90577 }
90578
90579
90580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
90581   void * jresult ;
90582   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
90583
90584   {
90585     try {
90586       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
90587     } catch (std::out_of_range& e) {
90588       {
90589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90590       };
90591     } catch (std::exception& e) {
90592       {
90593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90594       };
90595     } catch (Dali::DaliException e) {
90596       {
90597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90598       };
90599     } catch (...) {
90600       {
90601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90602       };
90603     }
90604   }
90605
90606   jresult = (void *)result;
90607   return jresult;
90608 }
90609
90610
90611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
90612   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90613
90614   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90615   {
90616     try {
90617       delete arg1;
90618     } catch (std::out_of_range& e) {
90619       {
90620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90621       };
90622     } catch (std::exception& e) {
90623       {
90624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90625       };
90626     } catch (Dali::DaliException e) {
90627       {
90628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90629       };
90630     } catch (...) {
90631       {
90632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90633       };
90634     }
90635   }
90636
90637 }
90638
90639
90640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
90641   unsigned int jresult ;
90642   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90643   bool result;
90644
90645   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90646   {
90647     try {
90648       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90649     } catch (std::out_of_range& e) {
90650       {
90651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90652       };
90653     } catch (std::exception& e) {
90654       {
90655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90656       };
90657     } catch (Dali::DaliException e) {
90658       {
90659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90660       };
90661     } catch (...) {
90662       {
90663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90664       };
90665     }
90666   }
90667
90668   jresult = result;
90669   return jresult;
90670 }
90671
90672
90673 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
90674   unsigned long jresult ;
90675   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90676   std::size_t result;
90677
90678   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90679   {
90680     try {
90681       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90682     } catch (std::out_of_range& e) {
90683       {
90684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90685       };
90686     } catch (std::exception& e) {
90687       {
90688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90689       };
90690     } catch (Dali::DaliException e) {
90691       {
90692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90693       };
90694     } catch (...) {
90695       {
90696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90697       };
90698     }
90699   }
90700
90701   jresult = (unsigned long)result;
90702   return jresult;
90703 }
90704
90705
90706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
90707   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90708   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90709
90710   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90711   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90712   {
90713     try {
90714       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
90715     } catch (std::out_of_range& e) {
90716       {
90717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90718       };
90719     } catch (std::exception& e) {
90720       {
90721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90722       };
90723     } catch (Dali::DaliException e) {
90724       {
90725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90726       };
90727     } catch (...) {
90728       {
90729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90730       };
90731     }
90732   }
90733
90734 }
90735
90736
90737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90738   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90739   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90740
90741   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90742   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90743   {
90744     try {
90745       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90746     } catch (std::out_of_range& e) {
90747       {
90748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90749       };
90750     } catch (std::exception& e) {
90751       {
90752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90753       };
90754     } catch (Dali::DaliException e) {
90755       {
90756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90757       };
90758     } catch (...) {
90759       {
90760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90761       };
90762     }
90763   }
90764
90765 }
90766
90767
90768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
90769   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90770   Dali::Actor arg2 ;
90771   bool arg3 ;
90772   Dali::Actor *argp2 ;
90773
90774   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90775   argp2 = (Dali::Actor *)jarg2;
90776   if (!argp2) {
90777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90778     return ;
90779   }
90780   arg2 = *argp2;
90781   arg3 = jarg3 ? true : false;
90782   {
90783     try {
90784       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
90785     } catch (std::out_of_range& e) {
90786       {
90787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90788       };
90789     } catch (std::exception& e) {
90790       {
90791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90792       };
90793     } catch (Dali::DaliException e) {
90794       {
90795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90796       };
90797     } catch (...) {
90798       {
90799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90800       };
90801     }
90802   }
90803
90804 }
90805
90806
90807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
90808   void * jresult ;
90809   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
90810
90811   {
90812     try {
90813       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
90814     } catch (std::out_of_range& e) {
90815       {
90816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90817       };
90818     } catch (std::exception& e) {
90819       {
90820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90821       };
90822     } catch (Dali::DaliException e) {
90823       {
90824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90825       };
90826     } catch (...) {
90827       {
90828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90829       };
90830     }
90831   }
90832
90833   jresult = (void *)result;
90834   return jresult;
90835 }
90836
90837
90838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
90839   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90840
90841   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90842   {
90843     try {
90844       delete arg1;
90845     } catch (std::out_of_range& e) {
90846       {
90847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90848       };
90849     } catch (std::exception& e) {
90850       {
90851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90852       };
90853     } catch (Dali::DaliException e) {
90854       {
90855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90856       };
90857     } catch (...) {
90858       {
90859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90860       };
90861     }
90862   }
90863
90864 }
90865
90866
90867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
90868   unsigned int jresult ;
90869   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90870   bool result;
90871
90872   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90873   {
90874     try {
90875       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);
90876     } catch (std::out_of_range& e) {
90877       {
90878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90879       };
90880     } catch (std::exception& e) {
90881       {
90882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90883       };
90884     } catch (Dali::DaliException e) {
90885       {
90886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90887       };
90888     } catch (...) {
90889       {
90890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90891       };
90892     }
90893   }
90894
90895   jresult = result;
90896   return jresult;
90897 }
90898
90899
90900 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
90901   unsigned long jresult ;
90902   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90903   std::size_t result;
90904
90905   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90906   {
90907     try {
90908       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);
90909     } catch (std::out_of_range& e) {
90910       {
90911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90912       };
90913     } catch (std::exception& e) {
90914       {
90915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90916       };
90917     } catch (Dali::DaliException e) {
90918       {
90919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90920       };
90921     } catch (...) {
90922       {
90923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90924       };
90925     }
90926   }
90927
90928   jresult = (unsigned long)result;
90929   return jresult;
90930 }
90931
90932
90933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
90934   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90935   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90936
90937   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90938   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90939   {
90940     try {
90941       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
90942     } catch (std::out_of_range& e) {
90943       {
90944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90945       };
90946     } catch (std::exception& e) {
90947       {
90948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90949       };
90950     } catch (Dali::DaliException e) {
90951       {
90952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90953       };
90954     } catch (...) {
90955       {
90956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90957       };
90958     }
90959   }
90960
90961 }
90962
90963
90964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90965   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90966   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90967
90968   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90969   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90970   {
90971     try {
90972       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
90973     } catch (std::out_of_range& e) {
90974       {
90975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90976       };
90977     } catch (std::exception& e) {
90978       {
90979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90980       };
90981     } catch (Dali::DaliException e) {
90982       {
90983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90984       };
90985     } catch (...) {
90986       {
90987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90988       };
90989     }
90990   }
90991
90992 }
90993
90994
90995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90996   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90997   Dali::Toolkit::StyleManager arg2 ;
90998   Dali::StyleChange::Type arg3 ;
90999   Dali::Toolkit::StyleManager *argp2 ;
91000
91001   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91002   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
91003   if (!argp2) {
91004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
91005     return ;
91006   }
91007   arg2 = *argp2;
91008   arg3 = (Dali::StyleChange::Type)jarg3;
91009   {
91010     try {
91011       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
91012     } catch (std::out_of_range& e) {
91013       {
91014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91015       };
91016     } catch (std::exception& e) {
91017       {
91018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91019       };
91020     } catch (Dali::DaliException e) {
91021       {
91022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91023       };
91024     } catch (...) {
91025       {
91026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91027       };
91028     }
91029   }
91030
91031 }
91032
91033
91034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
91035   void * jresult ;
91036   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
91037
91038   {
91039     try {
91040       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
91041     } catch (std::out_of_range& e) {
91042       {
91043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91044       };
91045     } catch (std::exception& e) {
91046       {
91047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91048       };
91049     } catch (Dali::DaliException e) {
91050       {
91051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91052       };
91053     } catch (...) {
91054       {
91055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91056       };
91057     }
91058   }
91059
91060   jresult = (void *)result;
91061   return jresult;
91062 }
91063
91064
91065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
91066   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91067
91068   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91069   {
91070     try {
91071       delete arg1;
91072     } catch (std::out_of_range& e) {
91073       {
91074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91075       };
91076     } catch (std::exception& e) {
91077       {
91078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91079       };
91080     } catch (Dali::DaliException e) {
91081       {
91082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91083       };
91084     } catch (...) {
91085       {
91086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91087       };
91088     }
91089   }
91090
91091 }
91092
91093
91094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
91095   unsigned int jresult ;
91096   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91097   bool result;
91098
91099   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91100   {
91101     try {
91102       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91103     } catch (std::out_of_range& e) {
91104       {
91105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91106       };
91107     } catch (std::exception& e) {
91108       {
91109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91110       };
91111     } catch (Dali::DaliException e) {
91112       {
91113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91114       };
91115     } catch (...) {
91116       {
91117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91118       };
91119     }
91120   }
91121
91122   jresult = result;
91123   return jresult;
91124 }
91125
91126
91127 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
91128   unsigned long jresult ;
91129   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91130   std::size_t result;
91131
91132   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91133   {
91134     try {
91135       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91136     } catch (std::out_of_range& e) {
91137       {
91138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91139       };
91140     } catch (std::exception& e) {
91141       {
91142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91143       };
91144     } catch (Dali::DaliException e) {
91145       {
91146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91147       };
91148     } catch (...) {
91149       {
91150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91151       };
91152     }
91153   }
91154
91155   jresult = (unsigned long)result;
91156   return jresult;
91157 }
91158
91159
91160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
91161   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91162   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91163
91164   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91165   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91166   {
91167     try {
91168       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
91169     } catch (std::out_of_range& e) {
91170       {
91171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91172       };
91173     } catch (std::exception& e) {
91174       {
91175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91176       };
91177     } catch (Dali::DaliException e) {
91178       {
91179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91180       };
91181     } catch (...) {
91182       {
91183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91184       };
91185     }
91186   }
91187
91188 }
91189
91190
91191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
91192   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91193   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91194
91195   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91196   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91197   {
91198     try {
91199       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
91200     } catch (std::out_of_range& e) {
91201       {
91202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91203       };
91204     } catch (std::exception& e) {
91205       {
91206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91207       };
91208     } catch (Dali::DaliException e) {
91209       {
91210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91211       };
91212     } catch (...) {
91213       {
91214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91215       };
91216     }
91217   }
91218
91219 }
91220
91221
91222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
91223   unsigned int jresult ;
91224   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91225   Dali::Toolkit::Button arg2 ;
91226   Dali::Toolkit::Button *argp2 ;
91227   bool result;
91228
91229   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91230   argp2 = (Dali::Toolkit::Button *)jarg2;
91231   if (!argp2) {
91232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
91233     return 0;
91234   }
91235   arg2 = *argp2;
91236   {
91237     try {
91238       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
91239     } catch (std::out_of_range& e) {
91240       {
91241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91242       };
91243     } catch (std::exception& e) {
91244       {
91245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91246       };
91247     } catch (Dali::DaliException e) {
91248       {
91249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91250       };
91251     } catch (...) {
91252       {
91253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91254       };
91255     }
91256   }
91257
91258   jresult = result;
91259   return jresult;
91260 }
91261
91262
91263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
91264   void * jresult ;
91265   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
91266
91267   {
91268     try {
91269       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
91270     } catch (std::out_of_range& e) {
91271       {
91272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91273       };
91274     } catch (std::exception& e) {
91275       {
91276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91277       };
91278     } catch (Dali::DaliException e) {
91279       {
91280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91281       };
91282     } catch (...) {
91283       {
91284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91285       };
91286     }
91287   }
91288
91289   jresult = (void *)result;
91290   return jresult;
91291 }
91292
91293
91294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
91295   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91296
91297   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91298   {
91299     try {
91300       delete arg1;
91301     } catch (std::out_of_range& e) {
91302       {
91303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91304       };
91305     } catch (std::exception& e) {
91306       {
91307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91308       };
91309     } catch (Dali::DaliException e) {
91310       {
91311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91312       };
91313     } catch (...) {
91314       {
91315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91316       };
91317     }
91318   }
91319
91320 }
91321
91322
91323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
91324   unsigned int jresult ;
91325   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91326   bool result;
91327
91328   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91329   {
91330     try {
91331       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
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 unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
91357   unsigned long jresult ;
91358   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91359   std::size_t result;
91360
91361   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91362   {
91363     try {
91364       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91365     } catch (std::out_of_range& e) {
91366       {
91367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91368       };
91369     } catch (std::exception& e) {
91370       {
91371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91372       };
91373     } catch (Dali::DaliException e) {
91374       {
91375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91376       };
91377     } catch (...) {
91378       {
91379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91380       };
91381     }
91382   }
91383
91384   jresult = (unsigned long)result;
91385   return jresult;
91386 }
91387
91388
91389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
91390   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91391   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91392
91393   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91394   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91395   {
91396     try {
91397       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
91398     } catch (std::out_of_range& e) {
91399       {
91400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91401       };
91402     } catch (std::exception& e) {
91403       {
91404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91405       };
91406     } catch (Dali::DaliException e) {
91407       {
91408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91409       };
91410     } catch (...) {
91411       {
91412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91413       };
91414     }
91415   }
91416
91417 }
91418
91419
91420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
91421   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91422   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91423
91424   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91425   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91426   {
91427     try {
91428       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
91429     } catch (std::out_of_range& e) {
91430       {
91431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91432       };
91433     } catch (std::exception& e) {
91434       {
91435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91436       };
91437     } catch (Dali::DaliException e) {
91438       {
91439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91440       };
91441     } catch (...) {
91442       {
91443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91444       };
91445     }
91446   }
91447
91448 }
91449
91450
91451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
91452   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91453   Dali::Toolkit::GaussianBlurView arg2 ;
91454   Dali::Toolkit::GaussianBlurView *argp2 ;
91455
91456   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91457   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
91458   if (!argp2) {
91459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
91460     return ;
91461   }
91462   arg2 = *argp2;
91463   {
91464     try {
91465       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
91466     } catch (std::out_of_range& e) {
91467       {
91468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91469       };
91470     } catch (std::exception& e) {
91471       {
91472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91473       };
91474     } catch (Dali::DaliException e) {
91475       {
91476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91477       };
91478     } catch (...) {
91479       {
91480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91481       };
91482     }
91483   }
91484
91485 }
91486
91487
91488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
91489   void * jresult ;
91490   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
91491
91492   {
91493     try {
91494       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
91495     } catch (std::out_of_range& e) {
91496       {
91497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91498       };
91499     } catch (std::exception& e) {
91500       {
91501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91502       };
91503     } catch (Dali::DaliException e) {
91504       {
91505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91506       };
91507     } catch (...) {
91508       {
91509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91510       };
91511     }
91512   }
91513
91514   jresult = (void *)result;
91515   return jresult;
91516 }
91517
91518
91519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
91520   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91521
91522   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91523   {
91524     try {
91525       delete arg1;
91526     } catch (std::out_of_range& e) {
91527       {
91528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91529       };
91530     } catch (std::exception& e) {
91531       {
91532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91533       };
91534     } catch (Dali::DaliException e) {
91535       {
91536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91537       };
91538     } catch (...) {
91539       {
91540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91541       };
91542     }
91543   }
91544
91545 }
91546
91547
91548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
91549   unsigned int jresult ;
91550   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91551   bool result;
91552
91553   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91554   {
91555     try {
91556       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);
91557     } catch (std::out_of_range& e) {
91558       {
91559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91560       };
91561     } catch (std::exception& e) {
91562       {
91563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91564       };
91565     } catch (Dali::DaliException e) {
91566       {
91567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91568       };
91569     } catch (...) {
91570       {
91571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91572       };
91573     }
91574   }
91575
91576   jresult = result;
91577   return jresult;
91578 }
91579
91580
91581 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
91582   unsigned long jresult ;
91583   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91584   std::size_t result;
91585
91586   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91587   {
91588     try {
91589       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);
91590     } catch (std::out_of_range& e) {
91591       {
91592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91593       };
91594     } catch (std::exception& e) {
91595       {
91596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91597       };
91598     } catch (Dali::DaliException e) {
91599       {
91600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91601       };
91602     } catch (...) {
91603       {
91604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91605       };
91606     }
91607   }
91608
91609   jresult = (unsigned long)result;
91610   return jresult;
91611 }
91612
91613
91614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
91615   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91616   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91617
91618   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91619   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91620   {
91621     try {
91622       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
91623     } catch (std::out_of_range& e) {
91624       {
91625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91626       };
91627     } catch (std::exception& e) {
91628       {
91629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91630       };
91631     } catch (Dali::DaliException e) {
91632       {
91633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91634       };
91635     } catch (...) {
91636       {
91637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91638       };
91639     }
91640   }
91641
91642 }
91643
91644
91645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
91646   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91647   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91648
91649   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91650   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91651   {
91652     try {
91653       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
91654     } catch (std::out_of_range& e) {
91655       {
91656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91657       };
91658     } catch (std::exception& e) {
91659       {
91660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91661       };
91662     } catch (Dali::DaliException e) {
91663       {
91664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91665       };
91666     } catch (...) {
91667       {
91668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91669       };
91670     }
91671   }
91672
91673 }
91674
91675
91676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
91677   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91678   Dali::Toolkit::PageTurnView arg2 ;
91679   unsigned int arg3 ;
91680   bool arg4 ;
91681   Dali::Toolkit::PageTurnView *argp2 ;
91682
91683   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91684   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
91685   if (!argp2) {
91686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
91687     return ;
91688   }
91689   arg2 = *argp2;
91690   arg3 = (unsigned int)jarg3;
91691   arg4 = jarg4 ? true : false;
91692   {
91693     try {
91694       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
91695     } catch (std::out_of_range& e) {
91696       {
91697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91698       };
91699     } catch (std::exception& e) {
91700       {
91701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91702       };
91703     } catch (Dali::DaliException e) {
91704       {
91705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91706       };
91707     } catch (...) {
91708       {
91709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91710       };
91711     }
91712   }
91713
91714 }
91715
91716
91717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
91718   void * jresult ;
91719   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
91720
91721   {
91722     try {
91723       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
91724     } catch (std::out_of_range& e) {
91725       {
91726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91727       };
91728     } catch (std::exception& e) {
91729       {
91730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91731       };
91732     } catch (Dali::DaliException e) {
91733       {
91734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91735       };
91736     } catch (...) {
91737       {
91738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91739       };
91740     }
91741   }
91742
91743   jresult = (void *)result;
91744   return jresult;
91745 }
91746
91747
91748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
91749   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91750
91751   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91752   {
91753     try {
91754       delete arg1;
91755     } catch (std::out_of_range& e) {
91756       {
91757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91758       };
91759     } catch (std::exception& e) {
91760       {
91761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91762       };
91763     } catch (Dali::DaliException e) {
91764       {
91765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91766       };
91767     } catch (...) {
91768       {
91769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91770       };
91771     }
91772   }
91773
91774 }
91775
91776
91777 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
91778   unsigned int jresult ;
91779   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91780   bool result;
91781
91782   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91783   {
91784     try {
91785       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
91786     } catch (std::out_of_range& e) {
91787       {
91788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91789       };
91790     } catch (std::exception& e) {
91791       {
91792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91793       };
91794     } catch (Dali::DaliException e) {
91795       {
91796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91797       };
91798     } catch (...) {
91799       {
91800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91801       };
91802     }
91803   }
91804
91805   jresult = result;
91806   return jresult;
91807 }
91808
91809
91810 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
91811   unsigned long jresult ;
91812   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91813   std::size_t result;
91814
91815   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91816   {
91817     try {
91818       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
91819     } catch (std::out_of_range& e) {
91820       {
91821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91822       };
91823     } catch (std::exception& e) {
91824       {
91825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91826       };
91827     } catch (Dali::DaliException e) {
91828       {
91829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91830       };
91831     } catch (...) {
91832       {
91833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91834       };
91835     }
91836   }
91837
91838   jresult = (unsigned long)result;
91839   return jresult;
91840 }
91841
91842
91843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
91844   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91845   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
91846
91847   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91848   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
91849   {
91850     try {
91851       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
91852     } catch (std::out_of_range& e) {
91853       {
91854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91855       };
91856     } catch (std::exception& e) {
91857       {
91858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91859       };
91860     } catch (Dali::DaliException e) {
91861       {
91862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91863       };
91864     } catch (...) {
91865       {
91866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91867       };
91868     }
91869   }
91870
91871 }
91872
91873
91874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
91875   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91876   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
91877
91878   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91879   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
91880   {
91881     try {
91882       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
91883     } catch (std::out_of_range& e) {
91884       {
91885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91886       };
91887     } catch (std::exception& e) {
91888       {
91889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91890       };
91891     } catch (Dali::DaliException e) {
91892       {
91893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91894       };
91895     } catch (...) {
91896       {
91897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91898       };
91899     }
91900   }
91901
91902 }
91903
91904
91905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
91906   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91907   Dali::Toolkit::PageTurnView arg2 ;
91908   Dali::Toolkit::PageTurnView *argp2 ;
91909
91910   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91911   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
91912   if (!argp2) {
91913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
91914     return ;
91915   }
91916   arg2 = *argp2;
91917   {
91918     try {
91919       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
91920     } catch (std::out_of_range& e) {
91921       {
91922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91923       };
91924     } catch (std::exception& e) {
91925       {
91926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91927       };
91928     } catch (Dali::DaliException e) {
91929       {
91930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91931       };
91932     } catch (...) {
91933       {
91934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91935       };
91936     }
91937   }
91938
91939 }
91940
91941
91942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
91943   void * jresult ;
91944   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
91945
91946   {
91947     try {
91948       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
91949     } catch (std::out_of_range& e) {
91950       {
91951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91952       };
91953     } catch (std::exception& e) {
91954       {
91955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91956       };
91957     } catch (Dali::DaliException e) {
91958       {
91959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91960       };
91961     } catch (...) {
91962       {
91963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91964       };
91965     }
91966   }
91967
91968   jresult = (void *)result;
91969   return jresult;
91970 }
91971
91972
91973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
91974   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91975
91976   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91977   {
91978     try {
91979       delete arg1;
91980     } catch (std::out_of_range& e) {
91981       {
91982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91983       };
91984     } catch (std::exception& e) {
91985       {
91986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91987       };
91988     } catch (Dali::DaliException e) {
91989       {
91990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91991       };
91992     } catch (...) {
91993       {
91994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91995       };
91996     }
91997   }
91998
91999 }
92000
92001
92002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
92003   unsigned int jresult ;
92004   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92005   bool result;
92006
92007   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92008   {
92009     try {
92010       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);
92011     } catch (std::out_of_range& e) {
92012       {
92013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92014       };
92015     } catch (std::exception& e) {
92016       {
92017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92018       };
92019     } catch (Dali::DaliException e) {
92020       {
92021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92022       };
92023     } catch (...) {
92024       {
92025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92026       };
92027     }
92028   }
92029
92030   jresult = result;
92031   return jresult;
92032 }
92033
92034
92035 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
92036   unsigned long jresult ;
92037   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92038   std::size_t result;
92039
92040   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92041   {
92042     try {
92043       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);
92044     } catch (std::out_of_range& e) {
92045       {
92046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92047       };
92048     } catch (std::exception& e) {
92049       {
92050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92051       };
92052     } catch (Dali::DaliException e) {
92053       {
92054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92055       };
92056     } catch (...) {
92057       {
92058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92059       };
92060     }
92061   }
92062
92063   jresult = (unsigned long)result;
92064   return jresult;
92065 }
92066
92067
92068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
92069   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92070   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92071
92072   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92073   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92074   {
92075     try {
92076       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
92077     } catch (std::out_of_range& e) {
92078       {
92079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92080       };
92081     } catch (std::exception& e) {
92082       {
92083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92084       };
92085     } catch (Dali::DaliException e) {
92086       {
92087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92088       };
92089     } catch (...) {
92090       {
92091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92092       };
92093     }
92094   }
92095
92096 }
92097
92098
92099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92100   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92101   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92102
92103   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92104   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92105   {
92106     try {
92107       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92108     } catch (std::out_of_range& e) {
92109       {
92110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92111       };
92112     } catch (std::exception& e) {
92113       {
92114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92115       };
92116     } catch (Dali::DaliException e) {
92117       {
92118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92119       };
92120     } catch (...) {
92121       {
92122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92123       };
92124     }
92125   }
92126
92127 }
92128
92129
92130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
92131   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92132   Dali::Toolkit::ProgressBar arg2 ;
92133   float arg3 ;
92134   float arg4 ;
92135   Dali::Toolkit::ProgressBar *argp2 ;
92136
92137   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92138   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
92139   if (!argp2) {
92140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
92141     return ;
92142   }
92143   arg2 = *argp2;
92144   arg3 = (float)jarg3;
92145   arg4 = (float)jarg4;
92146   {
92147     try {
92148       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
92149     } catch (std::out_of_range& e) {
92150       {
92151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92152       };
92153     } catch (std::exception& e) {
92154       {
92155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92156       };
92157     } catch (Dali::DaliException e) {
92158       {
92159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92160       };
92161     } catch (...) {
92162       {
92163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92164       };
92165     }
92166   }
92167
92168 }
92169
92170
92171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
92172   void * jresult ;
92173   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
92174
92175   {
92176     try {
92177       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
92178     } catch (std::out_of_range& e) {
92179       {
92180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92181       };
92182     } catch (std::exception& e) {
92183       {
92184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92185       };
92186     } catch (Dali::DaliException e) {
92187       {
92188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92189       };
92190     } catch (...) {
92191       {
92192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92193       };
92194     }
92195   }
92196
92197   jresult = (void *)result;
92198   return jresult;
92199 }
92200
92201
92202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
92203   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92204
92205   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92206   {
92207     try {
92208       delete arg1;
92209     } catch (std::out_of_range& e) {
92210       {
92211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92212       };
92213     } catch (std::exception& e) {
92214       {
92215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92216       };
92217     } catch (Dali::DaliException e) {
92218       {
92219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92220       };
92221     } catch (...) {
92222       {
92223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92224       };
92225     }
92226   }
92227
92228 }
92229
92230
92231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
92232   unsigned int jresult ;
92233   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92234   bool result;
92235
92236   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92237   {
92238     try {
92239       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);
92240     } catch (std::out_of_range& e) {
92241       {
92242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92243       };
92244     } catch (std::exception& e) {
92245       {
92246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92247       };
92248     } catch (Dali::DaliException e) {
92249       {
92250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92251       };
92252     } catch (...) {
92253       {
92254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92255       };
92256     }
92257   }
92258
92259   jresult = result;
92260   return jresult;
92261 }
92262
92263
92264 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
92265   unsigned long jresult ;
92266   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92267   std::size_t result;
92268
92269   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92270   {
92271     try {
92272       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);
92273     } catch (std::out_of_range& e) {
92274       {
92275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92276       };
92277     } catch (std::exception& e) {
92278       {
92279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92280       };
92281     } catch (Dali::DaliException e) {
92282       {
92283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92284       };
92285     } catch (...) {
92286       {
92287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92288       };
92289     }
92290   }
92291
92292   jresult = (unsigned long)result;
92293   return jresult;
92294 }
92295
92296
92297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
92298   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92299   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92300
92301   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92302   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92303   {
92304     try {
92305       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92306     } catch (std::out_of_range& e) {
92307       {
92308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92309       };
92310     } catch (std::exception& e) {
92311       {
92312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92313       };
92314     } catch (Dali::DaliException e) {
92315       {
92316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92317       };
92318     } catch (...) {
92319       {
92320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92321       };
92322     }
92323   }
92324
92325 }
92326
92327
92328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
92329   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92330   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92331
92332   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92333   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92334   {
92335     try {
92336       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92337     } catch (std::out_of_range& e) {
92338       {
92339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92340       };
92341     } catch (std::exception& e) {
92342       {
92343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92344       };
92345     } catch (Dali::DaliException e) {
92346       {
92347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92348       };
92349     } catch (...) {
92350       {
92351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92352       };
92353     }
92354   }
92355
92356 }
92357
92358
92359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
92360   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92361   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
92362
92363   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92364   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
92365   if (!arg2) {
92366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
92367     return ;
92368   }
92369   {
92370     try {
92371       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
92372     } catch (std::out_of_range& e) {
92373       {
92374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92375       };
92376     } catch (std::exception& e) {
92377       {
92378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92379       };
92380     } catch (Dali::DaliException e) {
92381       {
92382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92383       };
92384     } catch (...) {
92385       {
92386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92387       };
92388     }
92389   }
92390
92391 }
92392
92393
92394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
92395   void * jresult ;
92396   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
92397
92398   {
92399     try {
92400       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
92401     } catch (std::out_of_range& e) {
92402       {
92403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92404       };
92405     } catch (std::exception& e) {
92406       {
92407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92408       };
92409     } catch (Dali::DaliException e) {
92410       {
92411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92412       };
92413     } catch (...) {
92414       {
92415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92416       };
92417     }
92418   }
92419
92420   jresult = (void *)result;
92421   return jresult;
92422 }
92423
92424
92425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
92426   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92427
92428   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92429   {
92430     try {
92431       delete arg1;
92432     } catch (std::out_of_range& e) {
92433       {
92434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92435       };
92436     } catch (std::exception& e) {
92437       {
92438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92439       };
92440     } catch (Dali::DaliException e) {
92441       {
92442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92443       };
92444     } catch (...) {
92445       {
92446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92447       };
92448     }
92449   }
92450
92451 }
92452
92453
92454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
92455   unsigned int jresult ;
92456   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92457   bool result;
92458
92459   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92460   {
92461     try {
92462       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92463     } catch (std::out_of_range& e) {
92464       {
92465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92466       };
92467     } catch (std::exception& e) {
92468       {
92469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92470       };
92471     } catch (Dali::DaliException e) {
92472       {
92473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92474       };
92475     } catch (...) {
92476       {
92477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92478       };
92479     }
92480   }
92481
92482   jresult = result;
92483   return jresult;
92484 }
92485
92486
92487 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
92488   unsigned long jresult ;
92489   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92490   std::size_t result;
92491
92492   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92493   {
92494     try {
92495       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92496     } catch (std::out_of_range& e) {
92497       {
92498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92499       };
92500     } catch (std::exception& e) {
92501       {
92502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92503       };
92504     } catch (Dali::DaliException e) {
92505       {
92506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92507       };
92508     } catch (...) {
92509       {
92510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92511       };
92512     }
92513   }
92514
92515   jresult = (unsigned long)result;
92516   return jresult;
92517 }
92518
92519
92520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
92521   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92522   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92523
92524   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92525   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92526   {
92527     try {
92528       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92529     } catch (std::out_of_range& e) {
92530       {
92531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92532       };
92533     } catch (std::exception& e) {
92534       {
92535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92536       };
92537     } catch (Dali::DaliException e) {
92538       {
92539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92540       };
92541     } catch (...) {
92542       {
92543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92544       };
92545     }
92546   }
92547
92548 }
92549
92550
92551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
92552   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92553   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92554
92555   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92556   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92557   {
92558     try {
92559       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92560     } catch (std::out_of_range& e) {
92561       {
92562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92563       };
92564     } catch (std::exception& e) {
92565       {
92566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92567       };
92568     } catch (Dali::DaliException e) {
92569       {
92570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92571       };
92572     } catch (...) {
92573       {
92574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92575       };
92576     }
92577   }
92578
92579 }
92580
92581
92582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
92583   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92584   Dali::Vector2 *arg2 = 0 ;
92585
92586   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92587   arg2 = (Dali::Vector2 *)jarg2;
92588   if (!arg2) {
92589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
92590     return ;
92591   }
92592   {
92593     try {
92594       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
92595     } catch (std::out_of_range& e) {
92596       {
92597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92598       };
92599     } catch (std::exception& e) {
92600       {
92601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92602       };
92603     } catch (Dali::DaliException e) {
92604       {
92605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92606       };
92607     } catch (...) {
92608       {
92609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92610       };
92611     }
92612   }
92613
92614 }
92615
92616
92617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
92618   void * jresult ;
92619   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
92620
92621   {
92622     try {
92623       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
92624     } catch (std::out_of_range& e) {
92625       {
92626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92627       };
92628     } catch (std::exception& e) {
92629       {
92630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92631       };
92632     } catch (Dali::DaliException e) {
92633       {
92634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92635       };
92636     } catch (...) {
92637       {
92638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92639       };
92640     }
92641   }
92642
92643   jresult = (void *)result;
92644   return jresult;
92645 }
92646
92647
92648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
92649   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92650
92651   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92652   {
92653     try {
92654       delete arg1;
92655     } catch (std::out_of_range& e) {
92656       {
92657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92658       };
92659     } catch (std::exception& e) {
92660       {
92661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92662       };
92663     } catch (Dali::DaliException e) {
92664       {
92665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92666       };
92667     } catch (...) {
92668       {
92669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92670       };
92671     }
92672   }
92673
92674 }
92675
92676
92677
92678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
92679   unsigned int jresult ;
92680   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92681   bool result;
92682
92683   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92684   {
92685     try {
92686       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);
92687     } catch (std::out_of_range& e) {
92688       {
92689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92690       };
92691     } catch (std::exception& e) {
92692       {
92693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92694       };
92695     } catch (Dali::DaliException e) {
92696       {
92697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92698       };
92699     } catch (...) {
92700       {
92701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92702       };
92703     }
92704   }
92705
92706   jresult = result;
92707   return jresult;
92708 }
92709
92710
92711 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
92712   unsigned long jresult ;
92713   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92714   std::size_t result;
92715
92716   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92717   {
92718     try {
92719       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);
92720     } catch (std::out_of_range& e) {
92721       {
92722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92723       };
92724     } catch (std::exception& e) {
92725       {
92726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92727       };
92728     } catch (Dali::DaliException e) {
92729       {
92730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92731       };
92732     } catch (...) {
92733       {
92734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92735       };
92736     }
92737   }
92738
92739   jresult = (unsigned long)result;
92740   return jresult;
92741 }
92742
92743
92744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
92745   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92746   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92747
92748   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92749   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92750   {
92751     try {
92752       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92753     } catch (std::out_of_range& e) {
92754       {
92755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92756       };
92757     } catch (std::exception& e) {
92758       {
92759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92760       };
92761     } catch (Dali::DaliException e) {
92762       {
92763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92764       };
92765     } catch (...) {
92766       {
92767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92768       };
92769     }
92770   }
92771
92772 }
92773
92774
92775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
92776   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92777   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92778
92779   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92780   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92781   {
92782     try {
92783       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92784     } catch (std::out_of_range& e) {
92785       {
92786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92787       };
92788     } catch (std::exception& e) {
92789       {
92790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92791       };
92792     } catch (Dali::DaliException e) {
92793       {
92794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92795       };
92796     } catch (...) {
92797       {
92798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92799       };
92800     }
92801   }
92802
92803 }
92804
92805
92806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
92807   unsigned int jresult ;
92808   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92809   Dali::Toolkit::Control arg2 ;
92810   Dali::KeyEvent *arg3 = 0 ;
92811   Dali::Toolkit::Control *argp2 ;
92812   bool result;
92813
92814   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92815   argp2 = (Dali::Toolkit::Control *)jarg2;
92816   if (!argp2) {
92817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92818     return 0;
92819   }
92820   arg2 = *argp2;
92821   arg3 = (Dali::KeyEvent *)jarg3;
92822   if (!arg3) {
92823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
92824     return 0;
92825   }
92826   {
92827     try {
92828       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);
92829     } catch (std::out_of_range& e) {
92830       {
92831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92832       };
92833     } catch (std::exception& e) {
92834       {
92835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92836       };
92837     } catch (Dali::DaliException e) {
92838       {
92839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92840       };
92841     } catch (...) {
92842       {
92843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92844       };
92845     }
92846   }
92847
92848   jresult = result;
92849   return jresult;
92850 }
92851
92852
92853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
92854   void * jresult ;
92855   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
92856
92857   {
92858     try {
92859       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
92860     } catch (std::out_of_range& e) {
92861       {
92862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92863       };
92864     } catch (std::exception& e) {
92865       {
92866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92867       };
92868     } catch (Dali::DaliException e) {
92869       {
92870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92871       };
92872     } catch (...) {
92873       {
92874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92875       };
92876     }
92877   }
92878
92879   jresult = (void *)result;
92880   return jresult;
92881 }
92882
92883
92884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
92885   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92886
92887   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92888   {
92889     try {
92890       delete arg1;
92891     } catch (std::out_of_range& e) {
92892       {
92893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92894       };
92895     } catch (std::exception& e) {
92896       {
92897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92898       };
92899     } catch (Dali::DaliException e) {
92900       {
92901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92902       };
92903     } catch (...) {
92904       {
92905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92906       };
92907     }
92908   }
92909
92910 }
92911
92912
92913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
92914   unsigned int jresult ;
92915   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92916   bool result;
92917
92918   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92919   {
92920     try {
92921       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
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 unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
92947   unsigned long jresult ;
92948   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92949   std::size_t result;
92950
92951   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92952   {
92953     try {
92954       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92955     } catch (std::out_of_range& e) {
92956       {
92957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92958       };
92959     } catch (std::exception& e) {
92960       {
92961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92962       };
92963     } catch (Dali::DaliException e) {
92964       {
92965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92966       };
92967     } catch (...) {
92968       {
92969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92970       };
92971     }
92972   }
92973
92974   jresult = (unsigned long)result;
92975   return jresult;
92976 }
92977
92978
92979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
92980   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92981   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92982
92983   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92984   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92985   {
92986     try {
92987       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
92988     } catch (std::out_of_range& e) {
92989       {
92990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92991       };
92992     } catch (std::exception& e) {
92993       {
92994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92995       };
92996     } catch (Dali::DaliException e) {
92997       {
92998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92999       };
93000     } catch (...) {
93001       {
93002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93003       };
93004     }
93005   }
93006
93007 }
93008
93009
93010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
93011   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93012   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93013
93014   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93015   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93016   {
93017     try {
93018       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
93019     } catch (std::out_of_range& e) {
93020       {
93021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93022       };
93023     } catch (std::exception& e) {
93024       {
93025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93026       };
93027     } catch (Dali::DaliException e) {
93028       {
93029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93030       };
93031     } catch (...) {
93032       {
93033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93034       };
93035     }
93036   }
93037
93038 }
93039
93040
93041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
93042   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93043   Dali::Toolkit::Control arg2 ;
93044   Dali::Toolkit::Control *argp2 ;
93045
93046   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93047   argp2 = (Dali::Toolkit::Control *)jarg2;
93048   if (!argp2) {
93049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
93050     return ;
93051   }
93052   arg2 = *argp2;
93053   {
93054     try {
93055       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
93056     } catch (std::out_of_range& e) {
93057       {
93058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93059       };
93060     } catch (std::exception& e) {
93061       {
93062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93063       };
93064     } catch (Dali::DaliException e) {
93065       {
93066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93067       };
93068     } catch (...) {
93069       {
93070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93071       };
93072     }
93073   }
93074
93075 }
93076
93077
93078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
93079   void * jresult ;
93080   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
93081
93082   {
93083     try {
93084       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
93085     } catch (std::out_of_range& e) {
93086       {
93087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93088       };
93089     } catch (std::exception& e) {
93090       {
93091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93092       };
93093     } catch (Dali::DaliException e) {
93094       {
93095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93096       };
93097     } catch (...) {
93098       {
93099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93100       };
93101     }
93102   }
93103
93104   jresult = (void *)result;
93105   return jresult;
93106 }
93107
93108
93109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
93110   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93111
93112   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93113   {
93114     try {
93115       delete arg1;
93116     } catch (std::out_of_range& e) {
93117       {
93118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93119       };
93120     } catch (std::exception& e) {
93121       {
93122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93123       };
93124     } catch (Dali::DaliException e) {
93125       {
93126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93127       };
93128     } catch (...) {
93129       {
93130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93131       };
93132     }
93133   }
93134
93135 }
93136
93137
93138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
93139   unsigned int jresult ;
93140   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93141   bool result;
93142
93143   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93144   {
93145     try {
93146       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93147     } catch (std::out_of_range& e) {
93148       {
93149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93150       };
93151     } catch (std::exception& e) {
93152       {
93153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93154       };
93155     } catch (Dali::DaliException e) {
93156       {
93157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93158       };
93159     } catch (...) {
93160       {
93161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93162       };
93163     }
93164   }
93165
93166   jresult = result;
93167   return jresult;
93168 }
93169
93170
93171 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
93172   unsigned long jresult ;
93173   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93174   std::size_t result;
93175
93176   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93177   {
93178     try {
93179       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93180     } catch (std::out_of_range& e) {
93181       {
93182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93183       };
93184     } catch (std::exception& e) {
93185       {
93186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93187       };
93188     } catch (Dali::DaliException e) {
93189       {
93190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93191       };
93192     } catch (...) {
93193       {
93194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93195       };
93196     }
93197   }
93198
93199   jresult = (unsigned long)result;
93200   return jresult;
93201 }
93202
93203
93204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
93205   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93206   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93207
93208   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93209   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93210   {
93211     try {
93212       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
93213     } catch (std::out_of_range& e) {
93214       {
93215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93216       };
93217     } catch (std::exception& e) {
93218       {
93219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93220       };
93221     } catch (Dali::DaliException e) {
93222       {
93223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93224       };
93225     } catch (...) {
93226       {
93227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93228       };
93229     }
93230   }
93231
93232 }
93233
93234
93235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
93236   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93237   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93238
93239   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93240   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93241   {
93242     try {
93243       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
93244     } catch (std::out_of_range& e) {
93245       {
93246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93247       };
93248     } catch (std::exception& e) {
93249       {
93250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93251       };
93252     } catch (Dali::DaliException e) {
93253       {
93254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93255       };
93256     } catch (...) {
93257       {
93258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93259       };
93260     }
93261   }
93262
93263 }
93264
93265
93266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
93267   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93268   Dali::Toolkit::VideoView *arg2 = 0 ;
93269
93270   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93271   arg2 = (Dali::Toolkit::VideoView *)jarg2;
93272   if (!arg2) {
93273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
93274     return ;
93275   }
93276   {
93277     try {
93278       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
93279     } catch (std::out_of_range& e) {
93280       {
93281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93282       };
93283     } catch (std::exception& e) {
93284       {
93285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93286       };
93287     } catch (Dali::DaliException e) {
93288       {
93289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93290       };
93291     } catch (...) {
93292       {
93293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93294       };
93295     }
93296   }
93297
93298 }
93299
93300
93301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
93302   void * jresult ;
93303   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
93304
93305   {
93306     try {
93307       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
93308     } catch (std::out_of_range& e) {
93309       {
93310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93311       };
93312     } catch (std::exception& e) {
93313       {
93314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93315       };
93316     } catch (Dali::DaliException e) {
93317       {
93318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93319       };
93320     } catch (...) {
93321       {
93322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93323       };
93324     }
93325   }
93326
93327   jresult = (void *)result;
93328   return jresult;
93329 }
93330
93331
93332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
93333   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93334
93335   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93336   {
93337     try {
93338       delete arg1;
93339     } catch (std::out_of_range& e) {
93340       {
93341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93342       };
93343     } catch (std::exception& e) {
93344       {
93345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93346       };
93347     } catch (Dali::DaliException e) {
93348       {
93349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93350       };
93351     } catch (...) {
93352       {
93353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93354       };
93355     }
93356   }
93357
93358 }
93359
93360
93361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
93362   unsigned int jresult ;
93363   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93364   bool result;
93365
93366   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93367   {
93368     try {
93369       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93370     } catch (std::out_of_range& e) {
93371       {
93372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93373       };
93374     } catch (std::exception& e) {
93375       {
93376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93377       };
93378     } catch (Dali::DaliException e) {
93379       {
93380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93381       };
93382     } catch (...) {
93383       {
93384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93385       };
93386     }
93387   }
93388
93389   jresult = result;
93390   return jresult;
93391 }
93392
93393
93394 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
93395   unsigned long jresult ;
93396   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93397   std::size_t result;
93398
93399   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93400   {
93401     try {
93402       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93403     } catch (std::out_of_range& e) {
93404       {
93405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93406       };
93407     } catch (std::exception& e) {
93408       {
93409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93410       };
93411     } catch (Dali::DaliException e) {
93412       {
93413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93414       };
93415     } catch (...) {
93416       {
93417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93418       };
93419     }
93420   }
93421
93422   jresult = (unsigned long)result;
93423   return jresult;
93424 }
93425
93426
93427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
93428   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93429   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93430
93431   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93432   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93433   {
93434     try {
93435       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
93436     } catch (std::out_of_range& e) {
93437       {
93438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93439       };
93440     } catch (std::exception& e) {
93441       {
93442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93443       };
93444     } catch (Dali::DaliException e) {
93445       {
93446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93447       };
93448     } catch (...) {
93449       {
93450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93451       };
93452     }
93453   }
93454
93455 }
93456
93457
93458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
93459   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93460   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93461
93462   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93463   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93464   {
93465     try {
93466       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
93467     } catch (std::out_of_range& e) {
93468       {
93469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93470       };
93471     } catch (std::exception& e) {
93472       {
93473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93474       };
93475     } catch (Dali::DaliException e) {
93476       {
93477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93478       };
93479     } catch (...) {
93480       {
93481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93482       };
93483     }
93484   }
93485
93486 }
93487
93488
93489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
93490   unsigned int jresult ;
93491   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93492   Dali::Toolkit::Slider arg2 ;
93493   float arg3 ;
93494   Dali::Toolkit::Slider *argp2 ;
93495   bool result;
93496
93497   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93498   argp2 = (Dali::Toolkit::Slider *)jarg2;
93499   if (!argp2) {
93500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93501     return 0;
93502   }
93503   arg2 = *argp2;
93504   arg3 = (float)jarg3;
93505   {
93506     try {
93507       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
93508     } catch (std::out_of_range& e) {
93509       {
93510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93511       };
93512     } catch (std::exception& e) {
93513       {
93514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93515       };
93516     } catch (Dali::DaliException e) {
93517       {
93518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93519       };
93520     } catch (...) {
93521       {
93522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93523       };
93524     }
93525   }
93526
93527   jresult = result;
93528   return jresult;
93529 }
93530
93531
93532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
93533   void * jresult ;
93534   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
93535
93536   {
93537     try {
93538       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
93539     } catch (std::out_of_range& e) {
93540       {
93541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93542       };
93543     } catch (std::exception& e) {
93544       {
93545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93546       };
93547     } catch (Dali::DaliException e) {
93548       {
93549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93550       };
93551     } catch (...) {
93552       {
93553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93554       };
93555     }
93556   }
93557
93558   jresult = (void *)result;
93559   return jresult;
93560 }
93561
93562
93563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
93564   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93565
93566   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93567   {
93568     try {
93569       delete arg1;
93570     } catch (std::out_of_range& e) {
93571       {
93572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93573       };
93574     } catch (std::exception& e) {
93575       {
93576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93577       };
93578     } catch (Dali::DaliException e) {
93579       {
93580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93581       };
93582     } catch (...) {
93583       {
93584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93585       };
93586     }
93587   }
93588
93589 }
93590
93591
93592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
93593   unsigned int jresult ;
93594   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93595   bool result;
93596
93597   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93598   {
93599     try {
93600       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
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 unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
93626   unsigned long jresult ;
93627   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93628   std::size_t result;
93629
93630   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93631   {
93632     try {
93633       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93634     } catch (std::out_of_range& e) {
93635       {
93636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93637       };
93638     } catch (std::exception& e) {
93639       {
93640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93641       };
93642     } catch (Dali::DaliException e) {
93643       {
93644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93645       };
93646     } catch (...) {
93647       {
93648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93649       };
93650     }
93651   }
93652
93653   jresult = (unsigned long)result;
93654   return jresult;
93655 }
93656
93657
93658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
93659   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93660   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93661
93662   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93663   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93664   {
93665     try {
93666       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
93667     } catch (std::out_of_range& e) {
93668       {
93669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93670       };
93671     } catch (std::exception& e) {
93672       {
93673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93674       };
93675     } catch (Dali::DaliException e) {
93676       {
93677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93678       };
93679     } catch (...) {
93680       {
93681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93682       };
93683     }
93684   }
93685
93686 }
93687
93688
93689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
93690   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93691   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93692
93693   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93694   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93695   {
93696     try {
93697       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
93698     } catch (std::out_of_range& e) {
93699       {
93700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93701       };
93702     } catch (std::exception& e) {
93703       {
93704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93705       };
93706     } catch (Dali::DaliException e) {
93707       {
93708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93709       };
93710     } catch (...) {
93711       {
93712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93713       };
93714     }
93715   }
93716
93717 }
93718
93719
93720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
93721   unsigned int jresult ;
93722   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93723   Dali::Toolkit::Slider arg2 ;
93724   int arg3 ;
93725   Dali::Toolkit::Slider *argp2 ;
93726   bool result;
93727
93728   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93729   argp2 = (Dali::Toolkit::Slider *)jarg2;
93730   if (!argp2) {
93731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93732     return 0;
93733   }
93734   arg2 = *argp2;
93735   arg3 = (int)jarg3;
93736   {
93737     try {
93738       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
93739     } catch (std::out_of_range& e) {
93740       {
93741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93742       };
93743     } catch (std::exception& e) {
93744       {
93745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93746       };
93747     } catch (Dali::DaliException e) {
93748       {
93749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93750       };
93751     } catch (...) {
93752       {
93753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93754       };
93755     }
93756   }
93757
93758   jresult = result;
93759   return jresult;
93760 }
93761
93762
93763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
93764   void * jresult ;
93765   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
93766
93767   {
93768     try {
93769       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
93770     } catch (std::out_of_range& e) {
93771       {
93772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93773       };
93774     } catch (std::exception& e) {
93775       {
93776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93777       };
93778     } catch (Dali::DaliException e) {
93779       {
93780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93781       };
93782     } catch (...) {
93783       {
93784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93785       };
93786     }
93787   }
93788
93789   jresult = (void *)result;
93790   return jresult;
93791 }
93792
93793
93794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
93795   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93796
93797   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93798   {
93799     try {
93800       delete arg1;
93801     } catch (std::out_of_range& e) {
93802       {
93803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93804       };
93805     } catch (std::exception& e) {
93806       {
93807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93808       };
93809     } catch (Dali::DaliException e) {
93810       {
93811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93812       };
93813     } catch (...) {
93814       {
93815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93816       };
93817     }
93818   }
93819
93820 }
93821
93822
93823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
93824   void * jresult ;
93825   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93826
93827   {
93828     try {
93829       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
93830     } catch (std::out_of_range& e) {
93831       {
93832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93833       };
93834     } catch (std::exception& e) {
93835       {
93836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93837       };
93838     } catch (Dali::DaliException e) {
93839       {
93840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93841       };
93842     } catch (...) {
93843       {
93844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93845       };
93846     }
93847   }
93848
93849   jresult = (void *)result;
93850   return jresult;
93851 }
93852
93853
93854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
93855   void * jresult ;
93856   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
93857   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93858
93859   arg1 = (Dali::Toolkit::Ruler *)jarg1;
93860   {
93861     try {
93862       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
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_new_RulerPtr__SWIG_2(void * jarg1) {
93888   void * jresult ;
93889   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
93890   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93891
93892   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93893   if (!arg1) {
93894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93895     return 0;
93896   }
93897   {
93898     try {
93899       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
93900     } catch (std::out_of_range& e) {
93901       {
93902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93903       };
93904     } catch (std::exception& e) {
93905       {
93906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93907       };
93908     } catch (Dali::DaliException e) {
93909       {
93910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93911       };
93912     } catch (...) {
93913       {
93914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93915       };
93916     }
93917   }
93918
93919   jresult = (void *)result;
93920   return jresult;
93921 }
93922
93923
93924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
93925   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93926
93927   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93928   {
93929     try {
93930       delete arg1;
93931     } catch (std::out_of_range& e) {
93932       {
93933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93934       };
93935     } catch (std::exception& e) {
93936       {
93937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93938       };
93939     } catch (Dali::DaliException e) {
93940       {
93941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93942       };
93943     } catch (...) {
93944       {
93945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93946       };
93947     }
93948   }
93949
93950 }
93951
93952
93953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
93954   void * jresult ;
93955   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93956   Dali::Toolkit::Ruler *result = 0 ;
93957
93958   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93959   {
93960     try {
93961       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
93962     } catch (std::out_of_range& e) {
93963       {
93964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93965       };
93966     } catch (std::exception& e) {
93967       {
93968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93969       };
93970     } catch (Dali::DaliException e) {
93971       {
93972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93973       };
93974     } catch (...) {
93975       {
93976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93977       };
93978     }
93979   }
93980
93981   jresult = (void *)result;
93982   return jresult;
93983 }
93984
93985
93986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
93987   void * jresult ;
93988   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93989   Dali::Toolkit::Ruler *result = 0 ;
93990
93991   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93992   {
93993     try {
93994       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
93995     } catch (std::out_of_range& e) {
93996       {
93997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93998       };
93999     } catch (std::exception& e) {
94000       {
94001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94002       };
94003     } catch (Dali::DaliException e) {
94004       {
94005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94006       };
94007     } catch (...) {
94008       {
94009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94010       };
94011     }
94012   }
94013
94014   jresult = (void *)result;
94015   return jresult;
94016 }
94017
94018
94019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
94020   void * jresult ;
94021   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94022   Dali::Toolkit::Ruler *result = 0 ;
94023
94024   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94025   {
94026     try {
94027       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
94028     } catch (std::out_of_range& e) {
94029       {
94030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94031       };
94032     } catch (std::exception& e) {
94033       {
94034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94035       };
94036     } catch (Dali::DaliException e) {
94037       {
94038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94039       };
94040     } catch (...) {
94041       {
94042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94043       };
94044     }
94045   }
94046
94047   jresult = (void *)result;
94048   return jresult;
94049 }
94050
94051
94052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
94053   void * jresult ;
94054   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94055   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
94056   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94057
94058   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94059   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
94060   if (!arg2) {
94061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
94062     return 0;
94063   }
94064   {
94065     try {
94066       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
94067     } catch (std::out_of_range& e) {
94068       {
94069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94070       };
94071     } catch (std::exception& e) {
94072       {
94073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94074       };
94075     } catch (Dali::DaliException e) {
94076       {
94077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94078       };
94079     } catch (...) {
94080       {
94081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94082       };
94083     }
94084   }
94085
94086   jresult = (void *)result;
94087   return jresult;
94088 }
94089
94090
94091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
94092   void * jresult ;
94093   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94094   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94095   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94096
94097   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94098   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94099   {
94100     try {
94101       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
94102     } catch (std::out_of_range& e) {
94103       {
94104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94105       };
94106     } catch (std::exception& e) {
94107       {
94108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94109       };
94110     } catch (Dali::DaliException e) {
94111       {
94112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94113       };
94114     } catch (...) {
94115       {
94116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94117       };
94118     }
94119   }
94120
94121   jresult = (void *)result;
94122   return jresult;
94123 }
94124
94125
94126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
94127   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94128
94129   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94130   {
94131     try {
94132       (arg1)->Reset();
94133     } catch (std::out_of_range& e) {
94134       {
94135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94136       };
94137     } catch (std::exception& e) {
94138       {
94139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94140       };
94141     } catch (Dali::DaliException e) {
94142       {
94143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94144       };
94145     } catch (...) {
94146       {
94147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94148       };
94149     }
94150   }
94151
94152 }
94153
94154
94155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
94156   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94157   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94158
94159   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94160   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94161   {
94162     try {
94163       (arg1)->Reset(arg2);
94164     } catch (std::out_of_range& e) {
94165       {
94166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94167       };
94168     } catch (std::exception& e) {
94169       {
94170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94171       };
94172     } catch (Dali::DaliException e) {
94173       {
94174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94175       };
94176     } catch (...) {
94177       {
94178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94179       };
94180     }
94181   }
94182
94183 }
94184
94185
94186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
94187   void * jresult ;
94188   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94189   Dali::Toolkit::Ruler *result = 0 ;
94190
94191   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94192   {
94193     try {
94194       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
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 float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
94220   float jresult ;
94221   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94222   float arg2 ;
94223   float arg3 ;
94224   float result;
94225
94226   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94227   arg2 = (float)jarg2;
94228   arg3 = (float)jarg3;
94229   {
94230     try {
94231       result = (float)(*arg1)->Snap(arg2,arg3);
94232     } catch (std::out_of_range& e) {
94233       {
94234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94235       };
94236     } catch (std::exception& e) {
94237       {
94238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94239       };
94240     } catch (Dali::DaliException e) {
94241       {
94242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94243       };
94244     } catch (...) {
94245       {
94246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94247       };
94248     }
94249   }
94250
94251   jresult = result;
94252   return jresult;
94253 }
94254
94255
94256 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
94257   float jresult ;
94258   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94259   float arg2 ;
94260   float result;
94261
94262   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94263   arg2 = (float)jarg2;
94264   {
94265     try {
94266       result = (float)(*arg1)->Snap(arg2);
94267     } catch (std::out_of_range& e) {
94268       {
94269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94270       };
94271     } catch (std::exception& e) {
94272       {
94273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94274       };
94275     } catch (Dali::DaliException e) {
94276       {
94277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94278       };
94279     } catch (...) {
94280       {
94281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94282       };
94283     }
94284   }
94285
94286   jresult = result;
94287   return jresult;
94288 }
94289
94290
94291 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
94292   float jresult ;
94293   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94294   unsigned int arg2 ;
94295   unsigned int *arg3 = 0 ;
94296   bool arg4 ;
94297   float result;
94298
94299   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94300   arg2 = (unsigned int)jarg2;
94301   arg3 = (unsigned int *)jarg3;
94302   arg4 = jarg4 ? true : false;
94303   {
94304     try {
94305       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
94306     } catch (std::out_of_range& e) {
94307       {
94308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94309       };
94310     } catch (std::exception& e) {
94311       {
94312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94313       };
94314     } catch (Dali::DaliException e) {
94315       {
94316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94317       };
94318     } catch (...) {
94319       {
94320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94321       };
94322     }
94323   }
94324
94325   jresult = result;
94326   return jresult;
94327 }
94328
94329
94330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
94331   unsigned int jresult ;
94332   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94333   float arg2 ;
94334   bool arg3 ;
94335   unsigned int result;
94336
94337   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94338   arg2 = (float)jarg2;
94339   arg3 = jarg3 ? true : false;
94340   {
94341     try {
94342       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
94343     } catch (std::out_of_range& e) {
94344       {
94345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94346       };
94347     } catch (std::exception& e) {
94348       {
94349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94350       };
94351     } catch (Dali::DaliException e) {
94352       {
94353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94354       };
94355     } catch (...) {
94356       {
94357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94358       };
94359     }
94360   }
94361
94362   jresult = result;
94363   return jresult;
94364 }
94365
94366
94367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
94368   unsigned int jresult ;
94369   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94370   unsigned int result;
94371
94372   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94373   {
94374     try {
94375       result = (unsigned int)(*arg1)->GetTotalPages();
94376     } catch (std::out_of_range& e) {
94377       {
94378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94379       };
94380     } catch (std::exception& e) {
94381       {
94382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94383       };
94384     } catch (Dali::DaliException e) {
94385       {
94386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94387       };
94388     } catch (...) {
94389       {
94390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94391       };
94392     }
94393   }
94394
94395   jresult = result;
94396   return jresult;
94397 }
94398
94399
94400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
94401   int jresult ;
94402   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94403   Dali::Toolkit::Ruler::RulerType result;
94404
94405   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94406   {
94407     try {
94408       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
94409     } catch (std::out_of_range& e) {
94410       {
94411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94412       };
94413     } catch (std::exception& e) {
94414       {
94415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94416       };
94417     } catch (Dali::DaliException e) {
94418       {
94419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94420       };
94421     } catch (...) {
94422       {
94423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94424       };
94425     }
94426   }
94427
94428   jresult = (int)result;
94429   return jresult;
94430 }
94431
94432
94433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
94434   unsigned int jresult ;
94435   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94436   bool result;
94437
94438   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94439   {
94440     try {
94441       result = (bool)(*arg1)->IsEnabled();
94442     } catch (std::out_of_range& e) {
94443       {
94444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94445       };
94446     } catch (std::exception& e) {
94447       {
94448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94449       };
94450     } catch (Dali::DaliException e) {
94451       {
94452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94453       };
94454     } catch (...) {
94455       {
94456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94457       };
94458     }
94459   }
94460
94461   jresult = result;
94462   return jresult;
94463 }
94464
94465
94466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
94467   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94468
94469   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94470   {
94471     try {
94472       (*arg1)->Enable();
94473     } catch (std::out_of_range& e) {
94474       {
94475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94476       };
94477     } catch (std::exception& e) {
94478       {
94479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94480       };
94481     } catch (Dali::DaliException e) {
94482       {
94483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94484       };
94485     } catch (...) {
94486       {
94487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94488       };
94489     }
94490   }
94491
94492 }
94493
94494
94495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
94496   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94497
94498   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94499   {
94500     try {
94501       (*arg1)->Disable();
94502     } catch (std::out_of_range& e) {
94503       {
94504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94505       };
94506     } catch (std::exception& e) {
94507       {
94508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94509       };
94510     } catch (Dali::DaliException e) {
94511       {
94512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94513       };
94514     } catch (...) {
94515       {
94516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94517       };
94518     }
94519   }
94520
94521 }
94522
94523
94524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
94525   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94526   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
94527   Dali::Toolkit::RulerDomain *argp2 ;
94528
94529   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94530   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
94531   if (!argp2) {
94532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
94533     return ;
94534   }
94535   arg2 = *argp2;
94536   {
94537     try {
94538       (*arg1)->SetDomain(arg2);
94539     } catch (std::out_of_range& e) {
94540       {
94541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94542       };
94543     } catch (std::exception& e) {
94544       {
94545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94546       };
94547     } catch (Dali::DaliException e) {
94548       {
94549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94550       };
94551     } catch (...) {
94552       {
94553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94554       };
94555     }
94556   }
94557
94558 }
94559
94560
94561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
94562   void * jresult ;
94563   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94564   Dali::Toolkit::RulerDomain *result = 0 ;
94565
94566   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94567   {
94568     try {
94569       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
94570     } catch (std::out_of_range& e) {
94571       {
94572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94573       };
94574     } catch (std::exception& e) {
94575       {
94576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94577       };
94578     } catch (Dali::DaliException e) {
94579       {
94580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94581       };
94582     } catch (...) {
94583       {
94584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94585       };
94586     }
94587   }
94588
94589   jresult = (void *)result;
94590   return jresult;
94591 }
94592
94593
94594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
94595   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94596
94597   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94598   {
94599     try {
94600       (*arg1)->DisableDomain();
94601     } catch (std::out_of_range& e) {
94602       {
94603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94604       };
94605     } catch (std::exception& e) {
94606       {
94607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94608       };
94609     } catch (Dali::DaliException e) {
94610       {
94611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94612       };
94613     } catch (...) {
94614       {
94615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94616       };
94617     }
94618   }
94619
94620 }
94621
94622
94623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
94624   float jresult ;
94625   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94626   float arg2 ;
94627   float arg3 ;
94628   float arg4 ;
94629   float result;
94630
94631   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94632   arg2 = (float)jarg2;
94633   arg3 = (float)jarg3;
94634   arg4 = (float)jarg4;
94635   {
94636     try {
94637       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
94638     } catch (std::out_of_range& e) {
94639       {
94640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94641       };
94642     } catch (std::exception& e) {
94643       {
94644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94645       };
94646     } catch (Dali::DaliException e) {
94647       {
94648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94649       };
94650     } catch (...) {
94651       {
94652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94653       };
94654     }
94655   }
94656
94657   jresult = result;
94658   return jresult;
94659 }
94660
94661
94662 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
94663   float jresult ;
94664   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94665   float arg2 ;
94666   float arg3 ;
94667   float result;
94668
94669   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94670   arg2 = (float)jarg2;
94671   arg3 = (float)jarg3;
94672   {
94673     try {
94674       result = (float)(*arg1)->Clamp(arg2,arg3);
94675     } catch (std::out_of_range& e) {
94676       {
94677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94678       };
94679     } catch (std::exception& e) {
94680       {
94681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94682       };
94683     } catch (Dali::DaliException e) {
94684       {
94685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94686       };
94687     } catch (...) {
94688       {
94689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94690       };
94691     }
94692   }
94693
94694   jresult = result;
94695   return jresult;
94696 }
94697
94698
94699 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
94700   float jresult ;
94701   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94702   float arg2 ;
94703   float result;
94704
94705   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94706   arg2 = (float)jarg2;
94707   {
94708     try {
94709       result = (float)(*arg1)->Clamp(arg2);
94710     } catch (std::out_of_range& e) {
94711       {
94712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94713       };
94714     } catch (std::exception& e) {
94715       {
94716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94717       };
94718     } catch (Dali::DaliException e) {
94719       {
94720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94721       };
94722     } catch (...) {
94723       {
94724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94725       };
94726     }
94727   }
94728
94729   jresult = result;
94730   return jresult;
94731 }
94732
94733
94734 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
94735   float jresult ;
94736   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94737   float arg2 ;
94738   float arg3 ;
94739   float arg4 ;
94740   Dali::Toolkit::ClampState *arg5 = 0 ;
94741   float result;
94742
94743   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94744   arg2 = (float)jarg2;
94745   arg3 = (float)jarg3;
94746   arg4 = (float)jarg4;
94747   arg5 = (Dali::Toolkit::ClampState *)jarg5;
94748   if (!arg5) {
94749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
94750     return 0;
94751   }
94752   {
94753     try {
94754       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
94755     } catch (std::out_of_range& e) {
94756       {
94757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94758       };
94759     } catch (std::exception& e) {
94760       {
94761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94762       };
94763     } catch (Dali::DaliException e) {
94764       {
94765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94766       };
94767     } catch (...) {
94768       {
94769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94770       };
94771     }
94772   }
94773
94774   jresult = result;
94775   return jresult;
94776 }
94777
94778
94779 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
94780   float jresult ;
94781   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94782   float arg2 ;
94783   float arg3 ;
94784   float arg4 ;
94785   float arg5 ;
94786   float result;
94787
94788   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94789   arg2 = (float)jarg2;
94790   arg3 = (float)jarg3;
94791   arg4 = (float)jarg4;
94792   arg5 = (float)jarg5;
94793   {
94794     try {
94795       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
94796     } catch (std::out_of_range& e) {
94797       {
94798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94799       };
94800     } catch (std::exception& e) {
94801       {
94802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94803       };
94804     } catch (Dali::DaliException e) {
94805       {
94806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94807       };
94808     } catch (...) {
94809       {
94810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94811       };
94812     }
94813   }
94814
94815   jresult = result;
94816   return jresult;
94817 }
94818
94819
94820 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
94821   float jresult ;
94822   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94823   float arg2 ;
94824   float arg3 ;
94825   float arg4 ;
94826   float result;
94827
94828   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94829   arg2 = (float)jarg2;
94830   arg3 = (float)jarg3;
94831   arg4 = (float)jarg4;
94832   {
94833     try {
94834       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
94835     } catch (std::out_of_range& e) {
94836       {
94837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94838       };
94839     } catch (std::exception& e) {
94840       {
94841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94842       };
94843     } catch (Dali::DaliException e) {
94844       {
94845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94846       };
94847     } catch (...) {
94848       {
94849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94850       };
94851     }
94852   }
94853
94854   jresult = result;
94855   return jresult;
94856 }
94857
94858
94859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
94860   float jresult ;
94861   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94862   float arg2 ;
94863   float arg3 ;
94864   float result;
94865
94866   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94867   arg2 = (float)jarg2;
94868   arg3 = (float)jarg3;
94869   {
94870     try {
94871       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
94872     } catch (std::out_of_range& e) {
94873       {
94874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94875       };
94876     } catch (std::exception& e) {
94877       {
94878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94879       };
94880     } catch (Dali::DaliException e) {
94881       {
94882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94883       };
94884     } catch (...) {
94885       {
94886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94887       };
94888     }
94889   }
94890
94891   jresult = result;
94892   return jresult;
94893 }
94894
94895
94896 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
94897   float jresult ;
94898   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94899   float arg2 ;
94900   float result;
94901
94902   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94903   arg2 = (float)jarg2;
94904   {
94905     try {
94906       result = (float)(*arg1)->SnapAndClamp(arg2);
94907     } catch (std::out_of_range& e) {
94908       {
94909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94910       };
94911     } catch (std::exception& e) {
94912       {
94913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94914       };
94915     } catch (Dali::DaliException e) {
94916       {
94917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94918       };
94919     } catch (...) {
94920       {
94921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94922       };
94923     }
94924   }
94925
94926   jresult = result;
94927   return jresult;
94928 }
94929
94930
94931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
94932   float jresult ;
94933   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94934   float arg2 ;
94935   float arg3 ;
94936   float arg4 ;
94937   float arg5 ;
94938   Dali::Toolkit::ClampState *arg6 = 0 ;
94939   float result;
94940
94941   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94942   arg2 = (float)jarg2;
94943   arg3 = (float)jarg3;
94944   arg4 = (float)jarg4;
94945   arg5 = (float)jarg5;
94946   arg6 = (Dali::Toolkit::ClampState *)jarg6;
94947   if (!arg6) {
94948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
94949     return 0;
94950   }
94951   {
94952     try {
94953       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
94954     } catch (std::out_of_range& e) {
94955       {
94956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94957       };
94958     } catch (std::exception& e) {
94959       {
94960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94961       };
94962     } catch (Dali::DaliException e) {
94963       {
94964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94965       };
94966     } catch (...) {
94967       {
94968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94969       };
94970     }
94971   }
94972
94973   jresult = result;
94974   return jresult;
94975 }
94976
94977
94978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
94979   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94980
94981   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94982   {
94983     try {
94984       (*arg1)->Reference();
94985     } catch (std::out_of_range& e) {
94986       {
94987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94988       };
94989     } catch (std::exception& e) {
94990       {
94991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94992       };
94993     } catch (Dali::DaliException e) {
94994       {
94995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94996       };
94997     } catch (...) {
94998       {
94999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95000       };
95001     }
95002   }
95003
95004 }
95005
95006
95007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
95008   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95009
95010   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95011   {
95012     try {
95013       (*arg1)->Unreference();
95014     } catch (std::out_of_range& e) {
95015       {
95016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95017       };
95018     } catch (std::exception& e) {
95019       {
95020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95021       };
95022     } catch (Dali::DaliException e) {
95023       {
95024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95025       };
95026     } catch (...) {
95027       {
95028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95029       };
95030     }
95031   }
95032
95033 }
95034
95035
95036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
95037   int jresult ;
95038   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95039   int result;
95040
95041   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95042   {
95043     try {
95044       result = (int)(*arg1)->ReferenceCount();
95045     } catch (std::out_of_range& e) {
95046       {
95047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95048       };
95049     } catch (std::exception& e) {
95050       {
95051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95052       };
95053     } catch (Dali::DaliException e) {
95054       {
95055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95056       };
95057     } catch (...) {
95058       {
95059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95060       };
95061     }
95062   }
95063
95064   jresult = result;
95065   return jresult;
95066 }
95067
95068
95069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
95070   unsigned int jresult ;
95071   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95072   bool result;
95073
95074   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95075   {
95076     try {
95077       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95078     } catch (std::out_of_range& e) {
95079       {
95080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95081       };
95082     } catch (std::exception& e) {
95083       {
95084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95085       };
95086     } catch (Dali::DaliException e) {
95087       {
95088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95089       };
95090     } catch (...) {
95091       {
95092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95093       };
95094     }
95095   }
95096
95097   jresult = result;
95098   return jresult;
95099 }
95100
95101
95102 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
95103   unsigned long jresult ;
95104   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95105   std::size_t result;
95106
95107   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95108   {
95109     try {
95110       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95111     } catch (std::out_of_range& e) {
95112       {
95113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95114       };
95115     } catch (std::exception& e) {
95116       {
95117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95118       };
95119     } catch (Dali::DaliException e) {
95120       {
95121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95122       };
95123     } catch (...) {
95124       {
95125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95126       };
95127     }
95128   }
95129
95130   jresult = (unsigned long)result;
95131   return jresult;
95132 }
95133
95134
95135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
95136   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95137   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95138
95139   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95140   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95141   {
95142     try {
95143       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
95144     } catch (std::out_of_range& e) {
95145       {
95146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95147       };
95148     } catch (std::exception& e) {
95149       {
95150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95151       };
95152     } catch (Dali::DaliException e) {
95153       {
95154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95155       };
95156     } catch (...) {
95157       {
95158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95159       };
95160     }
95161   }
95162
95163 }
95164
95165
95166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
95167   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95168   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95169
95170   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95171   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95172   {
95173     try {
95174       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
95175     } catch (std::out_of_range& e) {
95176       {
95177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95178       };
95179     } catch (std::exception& e) {
95180       {
95181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95182       };
95183     } catch (Dali::DaliException e) {
95184       {
95185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95186       };
95187     } catch (...) {
95188       {
95189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95190       };
95191     }
95192   }
95193
95194 }
95195
95196
95197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
95198   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95199   Dali::Toolkit::Control arg2 ;
95200   Dali::Toolkit::Control *argp2 ;
95201
95202   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95203   argp2 = (Dali::Toolkit::Control *)jarg2;
95204   if (!argp2) {
95205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
95206     return ;
95207   }
95208   arg2 = *argp2;
95209   {
95210     try {
95211       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
95212     } catch (std::out_of_range& e) {
95213       {
95214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95215       };
95216     } catch (std::exception& e) {
95217       {
95218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95219       };
95220     } catch (Dali::DaliException e) {
95221       {
95222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95223       };
95224     } catch (...) {
95225       {
95226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95227       };
95228     }
95229   }
95230
95231 }
95232
95233
95234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
95235   void * jresult ;
95236   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
95237
95238   {
95239     try {
95240       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
95241     } catch (std::out_of_range& e) {
95242       {
95243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95244       };
95245     } catch (std::exception& e) {
95246       {
95247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95248       };
95249     } catch (Dali::DaliException e) {
95250       {
95251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95252       };
95253     } catch (...) {
95254       {
95255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95256       };
95257     }
95258   }
95259
95260   jresult = (void *)result;
95261   return jresult;
95262 }
95263
95264
95265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
95266   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95267
95268   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95269   {
95270     try {
95271       delete arg1;
95272     } catch (std::out_of_range& e) {
95273       {
95274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95275       };
95276     } catch (std::exception& e) {
95277       {
95278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95279       };
95280     } catch (Dali::DaliException e) {
95281       {
95282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95283       };
95284     } catch (...) {
95285       {
95286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95287       };
95288     }
95289   }
95290
95291 }
95292
95293 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
95294   Dali::RefObject *result = NULL;
95295
95296   if (arg1)
95297   {
95298     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
95299   }
95300   return result;
95301 }
95302
95303 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
95304     return (Dali::RefObject *)jarg1;
95305 }
95306
95307 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
95308     return (Dali::SignalObserver *)jarg1;
95309 }
95310
95311 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
95312     return (Dali::ConnectionTrackerInterface *)jarg1;
95313 }
95314
95315 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
95316     return (Dali::BaseHandle *)jarg1;
95317 }
95318
95319 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
95320     return (Dali::BaseHandle *)jarg1;
95321 }
95322
95323 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
95324     return (Dali::BaseHandle *)jarg1;
95325 }
95326
95327 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
95328     return (Dali::BaseHandle *)jarg1;
95329 }
95330
95331 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
95332     return (Dali::BaseHandle *)jarg1;
95333 }
95334
95335 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
95336     return (Dali::BaseHandle *)jarg1;
95337 }
95338
95339 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
95340     return (Dali::BaseHandle *)jarg1;
95341 }
95342
95343 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
95344     return (Dali::BaseHandle *)jarg1;
95345 }
95346
95347 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
95348     return (Dali::BaseHandle *)jarg1;
95349 }
95350
95351 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
95352     return (Dali::BaseHandle *)jarg1;
95353 }
95354
95355 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
95356     return (Dali::BaseHandle *)jarg1;
95357 }
95358
95359 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
95360     return (Dali::BaseHandle *)jarg1;
95361 }
95362
95363 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
95364     return (Dali::Handle *)jarg1;
95365 }
95366
95367 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
95368     return (Dali::Handle *)jarg1;
95369 }
95370
95371 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
95372     return (Dali::BaseHandle *)jarg1;
95373 }
95374
95375 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
95376     return (Dali::BaseHandle *)jarg1;
95377 }
95378
95379 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
95380     return (Dali::Handle *)jarg1;
95381 }
95382
95383 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
95384     return (Dali::BaseHandle *)jarg1;
95385 }
95386
95387 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
95388     return (Dali::BaseHandle *)jarg1;
95389 }
95390
95391 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
95392     return (Dali::Handle *)jarg1;
95393 }
95394
95395 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
95396     return (Dali::GestureDetector *)jarg1;
95397 }
95398
95399 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
95400     return (Dali::Gesture *)jarg1;
95401 }
95402
95403 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
95404     return (Dali::Handle *)jarg1;
95405 }
95406
95407 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
95408     return (Dali::Actor *)jarg1;
95409 }
95410
95411 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
95412     return (Dali::RefObject *)jarg1;
95413 }
95414
95415 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
95416     return (Dali::Actor *)jarg1;
95417 }
95418
95419 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
95420     return (Dali::GestureDetector *)jarg1;
95421 }
95422
95423 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
95424     return (Dali::Gesture *)jarg1;
95425 }
95426
95427 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
95428     return (Dali::GestureDetector *)jarg1;
95429 }
95430
95431 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
95432     return (Dali::Gesture *)jarg1;
95433 }
95434
95435 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
95436     return (Dali::GestureDetector *)jarg1;
95437 }
95438
95439 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
95440     return (Dali::Gesture *)jarg1;
95441 }
95442
95443 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
95444     return (Dali::BaseHandle *)jarg1;
95445 }
95446
95447 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
95448     return (Dali::Handle *)jarg1;
95449 }
95450
95451 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
95452     return (Dali::Handle *)jarg1;
95453 }
95454
95455 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
95456     return (Dali::Handle *)jarg1;
95457 }
95458
95459 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
95460     return (Dali::RefObject *)jarg1;
95461 }
95462
95463 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
95464     return (Dali::Actor *)jarg1;
95465 }
95466
95467 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
95468     return (Dali::BaseHandle *)jarg1;
95469 }
95470
95471 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
95472     return (Dali::BaseHandle *)jarg1;
95473 }
95474
95475 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
95476     return (Dali::BaseHandle *)jarg1;
95477 }
95478
95479 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
95480     return (Dali::CustomActorImpl *)jarg1;
95481 }
95482
95483 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
95484     return (Dali::CustomActor *)jarg1;
95485 }
95486
95487 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
95488     return (Dali::BaseHandle *)jarg1;
95489 }
95490
95491 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
95492     return (Dali::Toolkit::Control *)jarg1;
95493 }
95494
95495 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
95496     return (Dali::Toolkit::Control *)jarg1;
95497 }
95498
95499 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
95500     return (Dali::Toolkit::Button *)jarg1;
95501 }
95502
95503 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
95504     return (Dali::Toolkit::Button *)jarg1;
95505 }
95506
95507 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
95508     return (Dali::Toolkit::Button *)jarg1;
95509 }
95510
95511 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
95512     return (Dali::Toolkit::Control *)jarg1;
95513 }
95514
95515 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
95516     return (Dali::Toolkit::Control *)jarg1;
95517 }
95518
95519 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
95520     return (Dali::Toolkit::Control *)jarg1;
95521 }
95522
95523 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
95524     return (Dali::Toolkit::Control *)jarg1;
95525 }
95526
95527 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
95528     return (Dali::Toolkit::Control *)jarg1;
95529 }
95530
95531 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
95532     return (Dali::RefObject *)jarg1;
95533 }
95534
95535 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
95536     return (Dali::Toolkit::Scrollable *)jarg1;
95537 }
95538
95539 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
95540     return (Dali::BaseHandle *)jarg1;
95541 }
95542
95543 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
95544     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
95545 }
95546
95547 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
95548     return (Dali::RefObject *)jarg1;
95549 }
95550
95551 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
95552     return (Dali::Toolkit::Ruler *)jarg1;
95553 }
95554
95555 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
95556     return (Dali::Toolkit::Ruler *)jarg1;
95557 }
95558
95559 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
95560     return (Dali::Toolkit::Scrollable *)jarg1;
95561 }
95562
95563 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
95564     return (Dali::Toolkit::Control *)jarg1;
95565 }
95566
95567
95568 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
95569     return (Dali::Toolkit::Control *)jarg1;
95570 }
95571
95572 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
95573     return (Dali::BaseHandle *)jarg1;
95574 }
95575
95576 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
95577     return (Dali::BaseHandle *)jarg1;
95578 }
95579
95580 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
95581     return (Dali::Toolkit::Control *)jarg1;
95582 }
95583
95584 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
95585     return (Dali::Toolkit::Control *)jarg1;
95586 }
95587
95588 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
95589     return (Dali::Toolkit::Control *)jarg1;
95590 }
95591
95592 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
95593     return (Dali::Toolkit::Control *)jarg1;
95594 }
95595
95596 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
95597     return (Dali::Toolkit::Control *)jarg1;
95598 }
95599
95600 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
95601     return (Dali::Toolkit::Control *)jarg1;
95602 }
95603
95604 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
95605     return (Dali::Toolkit::PageTurnView *)jarg1;
95606 }
95607
95608 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
95609     return (Dali::Toolkit::PageTurnView *)jarg1;
95610 }
95611
95612 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
95613     return (Dali::Toolkit::Button *)jarg1;
95614 }
95615
95616 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
95617     return (Dali::BaseHandle *)jarg1;
95618 }
95619
95620 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
95621     return (Dali::BaseHandle *)jarg1;
95622 }
95623
95624 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
95625     return (Dali::BaseHandle *)jarg1;
95626 }
95627
95628 /*
95629  * Widget binding
95630  */
95631 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
95632     return (Dali::BaseHandle *)jarg1;
95633 }
95634
95635 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
95636     return (Dali::BaseObject *)jarg1;
95637 }
95638
95639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
95640   void * jresult ;
95641   Dali::Widget result;
95642
95643   {
95644     try {
95645       result = Dali::Widget::New();
95646     } catch (std::out_of_range& e) {
95647       {
95648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95649       };
95650     } catch (std::exception& e) {
95651       {
95652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95653       };
95654     } catch (...) {
95655       {
95656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95657       };
95658     }
95659   }
95660   jresult = new Dali::Widget((const Dali::Widget &)result);
95661   return jresult;
95662 }
95663
95664
95665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
95666   void * jresult ;
95667   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
95668   Dali::Widget result;
95669
95670   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95671
95672   if (!arg1) {
95673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
95674     return 0;
95675   }
95676   {
95677     try {
95678       jresult = new Dali::Widget(arg1);
95679     } catch (std::out_of_range& e) {
95680       {
95681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95682       };
95683     } catch (std::exception& e) {
95684       {
95685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95686       };
95687     } catch (...) {
95688       {
95689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95690       };
95691     }
95692   }
95693   return jresult;
95694 }
95695
95696
95697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
95698   void * jresult ;
95699   Dali::Widget *result = 0 ;
95700
95701   {
95702     try {
95703       result = (Dali::Widget *)new Dali::Widget();
95704     } catch (std::out_of_range& e) {
95705       {
95706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95707       };
95708     } catch (std::exception& e) {
95709       {
95710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95711       };
95712     } catch (...) {
95713       {
95714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95715       };
95716     }
95717   }
95718   jresult = (void *)result;
95719   return jresult;
95720 }
95721
95722
95723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
95724   void * jresult ;
95725   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
95726   Dali::Widget *arg2 = 0 ;
95727   Dali::Widget *result = 0 ;
95728
95729   arg1 = (Dali::Widget *)jarg1;
95730   arg2 = (Dali::Widget *)jarg2;
95731   if (!arg2) {
95732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
95733     return 0;
95734   }
95735   {
95736     try {
95737       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
95738     } catch (std::out_of_range& e) {
95739       {
95740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95741       };
95742     } catch (std::exception& e) {
95743       {
95744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95745       };
95746     } catch (...) {
95747       {
95748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95749       };
95750     }
95751   }
95752   jresult = (void *)result;
95753   return jresult;
95754 }
95755
95756
95757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
95758   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
95759
95760   arg1 = (Dali::Widget *)jarg1;
95761   {
95762     try {
95763       delete arg1;
95764     } catch (std::out_of_range& e) {
95765       {
95766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95767       };
95768     } catch (std::exception& e) {
95769       {
95770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95771       };
95772     } catch (...) {
95773       {
95774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95775       };
95776     }
95777   }
95778 }
95779
95780
95781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
95782   void * jresult ;
95783   SwigDirector_WidgetImpl* result;
95784   {
95785     try {
95786       result = new SwigDirector_WidgetImpl();
95787     } catch (std::out_of_range& e) {
95788       {
95789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95790       };
95791     } catch (std::exception& e) {
95792       {
95793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95794       };
95795     } catch (...) {
95796       {
95797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95798       };
95799     }
95800   }
95801   jresult = result;
95802   return jresult;
95803 }
95804
95805
95806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
95807   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95808   std::string *arg2 = 0 ;
95809   Dali::Window arg3 ;
95810   Dali::Window *argp3 ;
95811
95812   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95813   if (!jarg2) {
95814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95815     return ;
95816   }
95817   std::string arg2_str(jarg2);
95818   arg2 = &arg2_str;
95819   argp3 = (Dali::Window *)jarg3;
95820   if (!argp3) {
95821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95822     return ;
95823   }
95824   arg3 = *argp3;
95825   {
95826     try {
95827       (arg1)->OnCreate((std::string const &)*arg2,arg3);
95828     } catch (std::out_of_range& e) {
95829       {
95830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95831       };
95832     } catch (std::exception& e) {
95833       {
95834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95835       };
95836     } catch (...) {
95837       {
95838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95839       };
95840     }
95841   }
95842 }
95843
95844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
95845   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95846   std::string *arg2 = 0 ;
95847   Dali::Window arg3 ;
95848   Dali::Window *argp3 ;
95849
95850   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95851   if (!jarg2) {
95852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95853     return ;
95854   }
95855   std::string arg2_str(jarg2);
95856   arg2 = &arg2_str;
95857   argp3 = (Dali::Window *)jarg3;
95858   if (!argp3) {
95859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95860     return ;
95861   }
95862   arg3 = *argp3;
95863   {
95864     try {
95865       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
95866     } catch (std::out_of_range& e) {
95867       {
95868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95869       };
95870     } catch (std::exception& e) {
95871       {
95872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95873       };
95874     } catch (...) {
95875       {
95876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95877       };
95878     }
95879   }
95880 }
95881
95882
95883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
95884   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95885   std::string *arg2 = 0 ;
95886   Dali::Widget::Termination arg3 ;
95887
95888   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95889   if (!jarg2) {
95890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95891     return ;
95892   }
95893   std::string arg2_str(jarg2);
95894   arg2 = &arg2_str;
95895   arg3 = (Dali::Widget::Termination)jarg3;
95896   {
95897     try {
95898       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
95899     } catch (std::out_of_range& e) {
95900       {
95901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95902       };
95903     } catch (std::exception& e) {
95904       {
95905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95906       };
95907     } catch (...) {
95908       {
95909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95910       };
95911     }
95912   }
95913 }
95914
95915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
95916   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95917   std::string *arg2 = 0 ;
95918   Dali::Widget::Termination arg3 ;
95919
95920   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95921   if (!jarg2) {
95922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95923     return ;
95924   }
95925   std::string arg2_str(jarg2);
95926   arg2 = &arg2_str;
95927   arg3 = (Dali::Widget::Termination)jarg3;
95928   {
95929     try {
95930       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
95931     } catch (std::out_of_range& e) {
95932       {
95933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95934       };
95935     } catch (std::exception& e) {
95936       {
95937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95938       };
95939     } catch (...) {
95940       {
95941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95942       };
95943     }
95944   }
95945 }
95946
95947
95948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
95949   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95950
95951   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95952   {
95953     try {
95954       (arg1)->OnPause();
95955     } catch (std::out_of_range& e) {
95956       {
95957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95958       };
95959     } catch (std::exception& e) {
95960       {
95961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95962       };
95963     } catch (...) {
95964       {
95965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95966       };
95967     }
95968   }
95969 }
95970
95971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
95972   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95973
95974   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95975   {
95976     try {
95977       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
95978     } catch (std::out_of_range& e) {
95979       {
95980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95981       };
95982     } catch (std::exception& e) {
95983       {
95984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95985       };
95986     } catch (...) {
95987       {
95988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95989       };
95990     }
95991   }
95992 }
95993
95994
95995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
95996   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95997
95998   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95999   {
96000     try {
96001       (arg1)->OnResume();
96002     } catch (std::out_of_range& e) {
96003       {
96004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96005       };
96006     } catch (std::exception& e) {
96007       {
96008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96009       };
96010     } catch (...) {
96011       {
96012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96013       };
96014     }
96015   }
96016 }
96017
96018
96019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
96020   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96021
96022   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96023   {
96024     try {
96025       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
96026     } catch (std::out_of_range& e) {
96027       {
96028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96029       };
96030     } catch (std::exception& e) {
96031       {
96032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96033       };
96034     } catch (...) {
96035       {
96036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96037       };
96038     }
96039   }
96040 }
96041
96042
96043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
96044   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96045   Dali::Window arg2 ;
96046   Dali::Window *argp2 ;
96047
96048   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96049   argp2 = (Dali::Window *)jarg2;
96050   if (!argp2) {
96051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96052     return ;
96053   }
96054   arg2 = *argp2;
96055   {
96056     try {
96057       (arg1)->OnResize(arg2);
96058     } catch (std::out_of_range& e) {
96059       {
96060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96061       };
96062     } catch (std::exception& e) {
96063       {
96064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96065       };
96066     } catch (...) {
96067       {
96068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96069       };
96070     }
96071   }
96072 }
96073
96074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
96075   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96076   Dali::Window arg2 ;
96077   Dali::Window *argp2 ;
96078
96079   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96080   argp2 = (Dali::Window *)jarg2;
96081   if (!argp2) {
96082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96083     return ;
96084   }
96085   arg2 = *argp2;
96086   {
96087     try {
96088       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
96089     } catch (std::out_of_range& e) {
96090       {
96091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96092       };
96093     } catch (std::exception& e) {
96094       {
96095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96096       };
96097     } catch (...) {
96098       {
96099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96100       };
96101     }
96102   }
96103 }
96104
96105
96106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
96107   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96108   std::string *arg2 = 0 ;
96109   int arg3 ;
96110
96111   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96112   if (!jarg2) {
96113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96114     return ;
96115   }
96116   std::string arg2_str(jarg2);
96117   arg2 = &arg2_str;
96118   arg3 = (int)jarg3;
96119   {
96120     try {
96121       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
96122     } catch (std::out_of_range& e) {
96123       {
96124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96125       };
96126     } catch (std::exception& e) {
96127       {
96128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96129       };
96130     } catch (...) {
96131       {
96132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96133       };
96134     }
96135   }
96136 }
96137
96138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96139   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96140   std::string *arg2 = 0 ;
96141   int arg3 ;
96142
96143   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96144   if (!jarg2) {
96145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96146     return ;
96147   }
96148   std::string arg2_str(jarg2);
96149   arg2 = &arg2_str;
96150   arg3 = (int)jarg3;
96151   {
96152     try {
96153       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
96154     } catch (std::out_of_range& e) {
96155       {
96156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96157       };
96158     } catch (std::exception& e) {
96159       {
96160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96161       };
96162     } catch (...) {
96163       {
96164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96165       };
96166     }
96167   }
96168 }
96169
96170
96171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
96172   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96173   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96174   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96175
96176   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96177   arg2 = (Dali::SlotObserver *)jarg2;
96178   arg3 = (Dali::CallbackBase *)jarg3;
96179   {
96180     try {
96181       (arg1)->SignalConnected(arg2,arg3);
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 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96199   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96200   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96201   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96202
96203   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96204   arg2 = (Dali::SlotObserver *)jarg2;
96205   arg3 = (Dali::CallbackBase *)jarg3;
96206   {
96207     try {
96208       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
96209     } catch (std::out_of_range& e) {
96210       {
96211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96212       };
96213     } catch (std::exception& e) {
96214       {
96215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96216       };
96217     } catch (...) {
96218       {
96219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96220       };
96221     }
96222   }
96223 }
96224
96225
96226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
96227   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96228   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96229   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96230
96231   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96232   arg2 = (Dali::SlotObserver *)jarg2;
96233   arg3 = (Dali::CallbackBase *)jarg3;
96234   {
96235     try {
96236       (arg1)->SignalDisconnected(arg2,arg3);
96237     } catch (std::out_of_range& e) {
96238       {
96239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96240       };
96241     } catch (std::exception& e) {
96242       {
96243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96244       };
96245     } catch (...) {
96246       {
96247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96248       };
96249     }
96250   }
96251 }
96252
96253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96254   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96255   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96256   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96257
96258   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96259   arg2 = (Dali::SlotObserver *)jarg2;
96260   arg3 = (Dali::CallbackBase *)jarg3;
96261   {
96262     try {
96263       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
96264     } catch (std::out_of_range& e) {
96265       {
96266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96267       };
96268     } catch (std::exception& e) {
96269       {
96270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96271       };
96272     } catch (...) {
96273       {
96274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96275       };
96276     }
96277   }
96278 }
96279
96280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
96281   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96282   std::string *arg2 = 0 ;
96283
96284   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96285   if (!jarg2) {
96286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96287     return ;
96288   }
96289   std::string arg2_str(jarg2);
96290   arg2 = &arg2_str;
96291   {
96292     try {
96293       (arg1)->SetContentInfo((std::string const &)*arg2);
96294     } catch (std::out_of_range& e) {
96295       {
96296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96297       };
96298     } catch (std::exception& e) {
96299       {
96300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96301       };
96302     } catch (...) {
96303       {
96304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96305       };
96306     }
96307   }
96308 }
96309
96310
96311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
96312   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96313   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
96314
96315   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96316   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
96317   {
96318     try {
96319       (arg1)->SetImpl(arg2);
96320     } catch (std::out_of_range& e) {
96321       {
96322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96323       };
96324     } catch (std::exception& e) {
96325       {
96326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96327       };
96328     } catch (...) {
96329       {
96330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96331       };
96332     }
96333   }
96334 }
96335
96336 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) {
96337
96338   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
96339   if (director) {
96340     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
96341   }
96342 }
96343
96344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
96345   void * jresult ;
96346   Dali::Widget *arg1 = 0 ;
96347   SwigDirector_WidgetImpl *result = 0 ;
96348
96349   arg1 = (Dali::Widget *)jarg1;
96350   if (!arg1) {
96351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
96352     return 0;
96353   }
96354   {
96355     try {
96356       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
96357     } catch (std::out_of_range& e) {
96358       {
96359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96360       };
96361     } catch (std::exception& e) {
96362       {
96363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96364       };
96365     } catch (...) {
96366       {
96367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96368       };
96369     }
96370   }
96371
96372   jresult = (void *)result;
96373   return jresult;
96374 }
96375
96376
96377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
96378   void * jresult ;
96379   int *arg1 = (int *) 0 ;
96380   char ***arg2 ;
96381   std::string *arg3 = 0 ;
96382   Dali::WidgetApplication result;
96383   {
96384     int index = 0;
96385     int length = 0;
96386     char *retPtr;
96387     char *nextPtr;
96388     argWidgetC = jarg1;
96389     argWidgetV = new char*[jarg1 + 1];
96390
96391     retPtr = strtok_r( jarg2, " ", &nextPtr);
96392     if( retPtr )
96393     {
96394       length = strlen(retPtr);
96395     }
96396     argWidgetV[index] = new char[length + 1];
96397     if( retPtr )
96398     {
96399       strncpy(argWidgetV[index], retPtr, length);
96400     }
96401     argWidgetV[index][length] = '\0';
96402     index++;
96403
96404     while (index < jarg1)
96405     {
96406       length = 0;
96407       retPtr = strtok_r(NULL, " ", &nextPtr);
96408       if( retPtr )
96409       {
96410         length = strlen(retPtr);
96411       }
96412       argWidgetV[index] = new char[length + 1];
96413       if( retPtr )
96414       {
96415         strncpy(argWidgetV[index], retPtr, length);
96416       }
96417       argWidgetV[index][length] = '\0';
96418       index++;
96419     }
96420
96421     argWidgetV[jarg1] = NULL;
96422     argWidgetC = jarg1;
96423
96424     arg1 = &argWidgetC;
96425     arg2 = &argWidgetV;
96426   }
96427
96428   if (!jarg3) {
96429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96430     return 0;
96431   }
96432   std::string arg3_str(jarg3);
96433   arg3 = &arg3_str;
96434   {
96435     try {
96436       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
96437     } catch (std::out_of_range& e) {
96438       {
96439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96440       };
96441     } catch (std::exception& e) {
96442       {
96443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96444       };
96445     } catch (...) {
96446       {
96447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96448       };
96449     }
96450   }
96451   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
96452
96453   return jresult;
96454 }
96455
96456
96457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
96458   void * jresult ;
96459   Dali::WidgetApplication *result = 0 ;
96460
96461   {
96462     try {
96463       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
96464     } catch (std::out_of_range& e) {
96465       {
96466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96467       };
96468     } catch (std::exception& e) {
96469       {
96470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96471       };
96472     } catch (...) {
96473       {
96474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96475       };
96476     }
96477   }
96478   jresult = (void *)result;
96479   return jresult;
96480 }
96481
96482
96483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
96484   void * jresult ;
96485   Dali::WidgetApplication *arg1 = 0 ;
96486   Dali::WidgetApplication *result = 0 ;
96487
96488   arg1 = (Dali::WidgetApplication *)jarg1;
96489   if (!arg1) {
96490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96491     return 0;
96492   }
96493   {
96494     try {
96495       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
96496     } catch (std::out_of_range& e) {
96497       {
96498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96499       };
96500     } catch (std::exception& e) {
96501       {
96502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96503       };
96504     } catch (...) {
96505       {
96506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96507       };
96508     }
96509   }
96510   jresult = (void *)result;
96511   return jresult;
96512 }
96513
96514
96515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
96516   void * jresult ;
96517   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96518   Dali::WidgetApplication *arg2 = 0 ;
96519   Dali::WidgetApplication *result = 0 ;
96520
96521   arg1 = (Dali::WidgetApplication *)jarg1;
96522   arg2 = (Dali::WidgetApplication *)jarg2;
96523   if (!arg2) {
96524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96525     return 0;
96526   }
96527   {
96528     try {
96529       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
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 = (void *)result;
96545   return jresult;
96546 }
96547
96548
96549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
96550   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96551
96552   arg1 = (Dali::WidgetApplication *)jarg1;
96553   {
96554     try {
96555       delete arg1;
96556       if( argWidgetV )
96557       {
96558         // free string data
96559         for( int i=0; i < argWidgetC+1; i++)
96560         {
96561           delete [] argWidgetV[i];
96562         }
96563         delete [] argWidgetV;
96564       }
96565     } catch (std::out_of_range& e) {
96566       {
96567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96568       };
96569     } catch (std::exception& e) {
96570       {
96571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96572       };
96573     } catch (...) {
96574       {
96575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96576       };
96577     }
96578   }
96579 }
96580
96581
96582 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
96583 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
96584
96585 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
96586 {
96587   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
96588   return *widget;
96589 }
96590
96591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
96592   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96593   std::string *arg2 = 0 ;
96594
96595   arg1 = (Dali::WidgetApplication *)jarg1;
96596   if (!jarg2) {
96597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96598     return ;
96599   }
96600   std::string arg2_str(*jarg2);
96601   arg2 = &arg2_str;
96602
96603   if(!_CSharpCreateWidgetFunction)
96604   {
96605     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
96606   }
96607
96608   {
96609     try {
96610       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
96611     } catch (std::out_of_range& e) {
96612       {
96613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96614       };
96615     } catch (std::exception& e) {
96616       {
96617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96618       };
96619     } catch (...) {
96620       {
96621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96622       };
96623     }
96624   }
96625
96626   //Typemap argout in c++ file.
96627   //This will convert c++ string to c# string
96628   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
96629 }
96630
96631
96632 //for PixelBuffer and ImageLoading
96633
96634 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
96635     return (Dali::BaseHandle *)jarg1;
96636 }
96637
96638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
96639   void * jresult ;
96640   unsigned int arg1 ;
96641   unsigned int arg2 ;
96642   Dali::Pixel::Format arg3 ;
96643   Dali::Devel::PixelBuffer result;
96644
96645   arg1 = (unsigned int)jarg1;
96646   arg2 = (unsigned int)jarg2;
96647   arg3 = (Dali::Pixel::Format)jarg3;
96648   {
96649     try {
96650       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
96651     } catch (std::out_of_range& e) {
96652       {
96653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96654       };
96655     } catch (std::exception& e) {
96656       {
96657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96658       };
96659     } catch (...) {
96660       {
96661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96662       };
96663     }
96664   }
96665   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
96666   return jresult;
96667 }
96668
96669
96670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
96671   void * jresult ;
96672   Dali::Devel::PixelBuffer *result = 0 ;
96673
96674   {
96675     try {
96676       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
96677     } catch (std::out_of_range& e) {
96678       {
96679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96680       };
96681     } catch (std::exception& e) {
96682       {
96683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96684       };
96685     } catch (...) {
96686       {
96687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96688       };
96689     }
96690   }
96691   jresult = (void *)result;
96692   return jresult;
96693 }
96694
96695
96696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
96697   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96698
96699   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96700   {
96701     try {
96702       delete arg1;
96703     } catch (std::out_of_range& e) {
96704       {
96705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96706       };
96707     } catch (std::exception& e) {
96708       {
96709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96710       };
96711     } catch (...) {
96712       {
96713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96714       };
96715     }
96716   }
96717 }
96718
96719
96720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
96721   void * jresult ;
96722   Dali::Devel::PixelBuffer *arg1 = 0 ;
96723   Dali::Devel::PixelBuffer *result = 0 ;
96724
96725   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96726   if (!arg1) {
96727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
96728     return 0;
96729   }
96730   {
96731     try {
96732       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
96733     } catch (std::out_of_range& e) {
96734       {
96735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96736       };
96737     } catch (std::exception& e) {
96738       {
96739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96740       };
96741     } catch (...) {
96742       {
96743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96744       };
96745     }
96746   }
96747   jresult = (void *)result;
96748   return jresult;
96749 }
96750
96751
96752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
96753   void * jresult ;
96754   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96755   Dali::Devel::PixelBuffer *arg2 = 0 ;
96756   Dali::Devel::PixelBuffer *result = 0 ;
96757
96758   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96759   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
96760   if (!arg2) {
96761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
96762     return 0;
96763   }
96764   {
96765     try {
96766       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
96767     } catch (std::out_of_range& e) {
96768       {
96769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96770       };
96771     } catch (std::exception& e) {
96772       {
96773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96774       };
96775     } catch (...) {
96776       {
96777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96778       };
96779     }
96780   }
96781   jresult = (void *)result;
96782   return jresult;
96783 }
96784
96785
96786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
96787   void * jresult ;
96788   Dali::Devel::PixelBuffer *arg1 = 0 ;
96789   Dali::PixelData result;
96790
96791   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96792   if (!arg1) {
96793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
96794     return 0;
96795   }
96796   {
96797     try {
96798       result = Dali::Devel::PixelBuffer::Convert(*arg1);
96799     } catch (std::out_of_range& e) {
96800       {
96801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96802       };
96803     } catch (std::exception& e) {
96804       {
96805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96806       };
96807     } catch (...) {
96808       {
96809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96810       };
96811     }
96812   }
96813   jresult = new Dali::PixelData((const Dali::PixelData &)result);
96814   return jresult;
96815 }
96816
96817
96818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
96819   void * jresult ;
96820   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96821   Dali::PixelData result;
96822
96823   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96824   {
96825     try {
96826       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
96827     } catch (std::out_of_range& e) {
96828       {
96829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96830       };
96831     } catch (std::exception& e) {
96832       {
96833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96834       };
96835     } catch (...) {
96836       {
96837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96838       };
96839     }
96840   }
96841   jresult = new Dali::PixelData((const Dali::PixelData &)result);
96842   return jresult;
96843 }
96844
96845
96846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
96847   void * jresult ;
96848   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96849   unsigned char *result = 0 ;
96850
96851   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96852   {
96853     try {
96854       result = (unsigned char *)(arg1)->GetBuffer();
96855     } catch (std::out_of_range& e) {
96856       {
96857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96858       };
96859     } catch (std::exception& e) {
96860       {
96861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96862       };
96863     } catch (...) {
96864       {
96865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96866       };
96867     }
96868   }
96869   jresult = (void *)result;
96870   return jresult;
96871 }
96872
96873
96874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
96875   unsigned int jresult ;
96876   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96877   unsigned int result;
96878
96879   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96880   {
96881     try {
96882       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
96883     } catch (std::out_of_range& e) {
96884       {
96885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96886       };
96887     } catch (std::exception& e) {
96888       {
96889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96890       };
96891     } catch (...) {
96892       {
96893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96894       };
96895     }
96896   }
96897   jresult = result;
96898   return jresult;
96899 }
96900
96901
96902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
96903   unsigned int jresult ;
96904   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96905   unsigned int result;
96906
96907   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96908   {
96909     try {
96910       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
96911     } catch (std::out_of_range& e) {
96912       {
96913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96914       };
96915     } catch (std::exception& e) {
96916       {
96917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96918       };
96919     } catch (...) {
96920       {
96921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96922       };
96923     }
96924   }
96925   jresult = result;
96926   return jresult;
96927 }
96928
96929
96930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
96931   int jresult ;
96932   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96933   Dali::Pixel::Format result;
96934
96935   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96936   {
96937     try {
96938       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
96939     } catch (std::out_of_range& e) {
96940       {
96941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96942       };
96943     } catch (std::exception& e) {
96944       {
96945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96946       };
96947     } catch (...) {
96948       {
96949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96950       };
96951     }
96952   }
96953   jresult = (int)result;
96954   return jresult;
96955 }
96956
96957
96958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
96959   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96960   Dali::Devel::PixelBuffer arg2 ;
96961   float arg3 ;
96962   bool arg4 ;
96963   Dali::Devel::PixelBuffer *argp2 ;
96964
96965   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96966   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
96967   if (!argp2) {
96968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
96969     return ;
96970   }
96971   arg2 = *argp2;
96972   arg3 = (float)jarg3;
96973   arg4 = jarg4 ? true : false;
96974   {
96975     try {
96976       (arg1)->ApplyMask(arg2,arg3,arg4);
96977     } catch (std::out_of_range& e) {
96978       {
96979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96980       };
96981     } catch (std::exception& e) {
96982       {
96983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96984       };
96985     } catch (...) {
96986       {
96987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96988       };
96989     }
96990   }
96991 }
96992
96993
96994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
96995   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96996   Dali::Devel::PixelBuffer arg2 ;
96997   float arg3 ;
96998   Dali::Devel::PixelBuffer *argp2 ;
96999
97000   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97001   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97002   if (!argp2) {
97003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97004     return ;
97005   }
97006   arg2 = *argp2;
97007   arg3 = (float)jarg3;
97008   {
97009     try {
97010       (arg1)->ApplyMask(arg2,arg3);
97011     } catch (std::out_of_range& e) {
97012       {
97013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97014       };
97015     } catch (std::exception& e) {
97016       {
97017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97018       };
97019     } catch (...) {
97020       {
97021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97022       };
97023     }
97024   }
97025 }
97026
97027
97028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
97029   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97030   Dali::Devel::PixelBuffer arg2 ;
97031   Dali::Devel::PixelBuffer *argp2 ;
97032
97033   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97034   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97035   if (!argp2) {
97036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97037     return ;
97038   }
97039   arg2 = *argp2;
97040   {
97041     try {
97042       (arg1)->ApplyMask(arg2);
97043     } catch (std::out_of_range& e) {
97044       {
97045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97046       };
97047     } catch (std::exception& e) {
97048       {
97049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97050       };
97051     } catch (...) {
97052       {
97053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97054       };
97055     }
97056   }
97057 }
97058
97059
97060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
97061   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97062   float arg2 ;
97063
97064   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97065   arg2 = (float)jarg2;
97066   {
97067     try {
97068       (arg1)->ApplyGaussianBlur(arg2);
97069     } catch (std::out_of_range& e) {
97070       {
97071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97072       };
97073     } catch (std::exception& e) {
97074       {
97075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97076       };
97077     } catch (...) {
97078       {
97079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97080       };
97081     }
97082   }
97083 }
97084
97085
97086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
97087   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97088   uint16_t arg2 ;
97089   uint16_t arg3 ;
97090   uint16_t arg4 ;
97091   uint16_t arg5 ;
97092
97093   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97094   arg2 = (uint16_t)jarg2;
97095   arg3 = (uint16_t)jarg3;
97096   arg4 = (uint16_t)jarg4;
97097   arg5 = (uint16_t)jarg5;
97098   {
97099     try {
97100       (arg1)->Crop(arg2,arg3,arg4,arg5);
97101     } catch (std::out_of_range& e) {
97102       {
97103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97104       };
97105     } catch (std::exception& e) {
97106       {
97107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97108       };
97109     } catch (...) {
97110       {
97111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97112       };
97113     }
97114   }
97115 }
97116
97117
97118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
97119   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97120   uint16_t arg2 ;
97121   uint16_t arg3 ;
97122
97123   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97124   arg2 = (uint16_t)jarg2;
97125   arg3 = (uint16_t)jarg3;
97126   {
97127     try {
97128       (arg1)->Resize(arg2,arg3);
97129     } catch (std::out_of_range& e) {
97130       {
97131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97132       };
97133     } catch (std::exception& e) {
97134       {
97135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97136       };
97137     } catch (...) {
97138       {
97139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97140       };
97141     }
97142   }
97143 }
97144
97145 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void * jarg2) {
97146   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97147   Dali::Degree * arg2 ;
97148
97149   bool result = false;
97150
97151   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97152   arg2 = (Dali::Degree *)jarg2;
97153   {
97154     try {
97155       result = (arg1)->Rotate(*arg2);
97156     } catch (std::out_of_range& e) {
97157       {
97158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
97159       };
97160     } catch (std::exception& e) {
97161       {
97162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
97163       };
97164     } catch (...) {
97165       {
97166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
97167       };
97168     }
97169   }
97170   return result;
97171 }
97172
97173
97174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97175   void * jresult ;
97176   std::string *arg1 = 0 ;
97177   Dali::ImageDimensions arg2 ;
97178   Dali::FittingMode::Type arg3 ;
97179   Dali::SamplingMode::Type arg4 ;
97180   bool arg5 ;
97181   Dali::ImageDimensions *argp2 ;
97182   Dali::Devel::PixelBuffer result;
97183
97184   if (!jarg1) {
97185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97186     return 0;
97187   }
97188   std::string arg1_str(jarg1);
97189   arg1 = &arg1_str;
97190   argp2 = (Dali::ImageDimensions *)jarg2;
97191   if (!argp2) {
97192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97193     return 0;
97194   }
97195   arg2 = *argp2;
97196   arg3 = (Dali::FittingMode::Type)jarg3;
97197   arg4 = (Dali::SamplingMode::Type)jarg4;
97198   arg5 = jarg5 ? true : false;
97199   {
97200     try {
97201       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97202     } catch (std::out_of_range& e) {
97203       {
97204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97205       };
97206     } catch (std::exception& e) {
97207       {
97208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97209       };
97210     } catch (...) {
97211       {
97212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97213       };
97214     }
97215   }
97216   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97217
97218   return jresult;
97219 }
97220
97221
97222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97223   void * jresult ;
97224   std::string *arg1 = 0 ;
97225   Dali::ImageDimensions arg2 ;
97226   Dali::FittingMode::Type arg3 ;
97227   Dali::SamplingMode::Type arg4 ;
97228   Dali::ImageDimensions *argp2 ;
97229   Dali::Devel::PixelBuffer result;
97230
97231   if (!jarg1) {
97232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97233     return 0;
97234   }
97235   std::string arg1_str(jarg1);
97236   arg1 = &arg1_str;
97237   argp2 = (Dali::ImageDimensions *)jarg2;
97238   if (!argp2) {
97239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97240     return 0;
97241   }
97242   arg2 = *argp2;
97243   arg3 = (Dali::FittingMode::Type)jarg3;
97244   arg4 = (Dali::SamplingMode::Type)jarg4;
97245   {
97246     try {
97247       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
97248     } catch (std::out_of_range& e) {
97249       {
97250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97251       };
97252     } catch (std::exception& e) {
97253       {
97254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97255       };
97256     } catch (...) {
97257       {
97258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97259       };
97260     }
97261   }
97262   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97263
97264   return jresult;
97265 }
97266
97267
97268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97269   void * jresult ;
97270   std::string *arg1 = 0 ;
97271   Dali::ImageDimensions arg2 ;
97272   Dali::FittingMode::Type arg3 ;
97273   Dali::ImageDimensions *argp2 ;
97274   Dali::Devel::PixelBuffer result;
97275
97276   if (!jarg1) {
97277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97278     return 0;
97279   }
97280   std::string arg1_str(jarg1);
97281   arg1 = &arg1_str;
97282   argp2 = (Dali::ImageDimensions *)jarg2;
97283   if (!argp2) {
97284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97285     return 0;
97286   }
97287   arg2 = *argp2;
97288   arg3 = (Dali::FittingMode::Type)jarg3;
97289   {
97290     try {
97291       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
97292     } catch (std::out_of_range& e) {
97293       {
97294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97295       };
97296     } catch (std::exception& e) {
97297       {
97298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97299       };
97300     } catch (...) {
97301       {
97302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97303       };
97304     }
97305   }
97306   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97307
97308   return jresult;
97309 }
97310
97311
97312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
97313   void * jresult ;
97314   std::string *arg1 = 0 ;
97315   Dali::ImageDimensions arg2 ;
97316   Dali::ImageDimensions *argp2 ;
97317   Dali::Devel::PixelBuffer result;
97318
97319   if (!jarg1) {
97320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97321     return 0;
97322   }
97323   std::string arg1_str(jarg1);
97324   arg1 = &arg1_str;
97325   argp2 = (Dali::ImageDimensions *)jarg2;
97326   if (!argp2) {
97327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97328     return 0;
97329   }
97330   arg2 = *argp2;
97331   {
97332     try {
97333       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
97334     } catch (std::out_of_range& e) {
97335       {
97336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97337       };
97338     } catch (std::exception& e) {
97339       {
97340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97341       };
97342     } catch (...) {
97343       {
97344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97345       };
97346     }
97347   }
97348   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97349
97350   return jresult;
97351 }
97352
97353
97354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
97355   void * jresult ;
97356   std::string *arg1 = 0 ;
97357   Dali::Devel::PixelBuffer result;
97358
97359   if (!jarg1) {
97360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97361     return 0;
97362   }
97363   std::string arg1_str(jarg1);
97364   arg1 = &arg1_str;
97365   {
97366     try {
97367       result = Dali::LoadImageFromFile((std::string const &)*arg1);
97368     } catch (std::out_of_range& e) {
97369       {
97370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97371       };
97372     } catch (std::exception& e) {
97373       {
97374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97375       };
97376     } catch (...) {
97377       {
97378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97379       };
97380     }
97381   }
97382   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97383
97384   return jresult;
97385 }
97386
97387
97388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97389   void * jresult ;
97390   std::string *arg1 = 0 ;
97391   Dali::ImageDimensions arg2 ;
97392   Dali::FittingMode::Type arg3 ;
97393   Dali::SamplingMode::Type arg4 ;
97394   bool arg5 ;
97395   Dali::ImageDimensions *argp2 ;
97396   Dali::ImageDimensions result;
97397
97398   if (!jarg1) {
97399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97400     return 0;
97401   }
97402   std::string arg1_str(jarg1);
97403   arg1 = &arg1_str;
97404   argp2 = (Dali::ImageDimensions *)jarg2;
97405   if (!argp2) {
97406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97407     return 0;
97408   }
97409   arg2 = *argp2;
97410   arg3 = (Dali::FittingMode::Type)jarg3;
97411   arg4 = (Dali::SamplingMode::Type)jarg4;
97412   arg5 = jarg5 ? true : false;
97413   {
97414     try {
97415       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97416     } catch (std::out_of_range& e) {
97417       {
97418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97419       };
97420     } catch (std::exception& e) {
97421       {
97422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97423       };
97424     } catch (...) {
97425       {
97426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97427       };
97428     }
97429   }
97430   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97431
97432   return jresult;
97433 }
97434
97435
97436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97437   void * jresult ;
97438   std::string *arg1 = 0 ;
97439   Dali::ImageDimensions arg2 ;
97440   Dali::FittingMode::Type arg3 ;
97441   Dali::SamplingMode::Type arg4 ;
97442   Dali::ImageDimensions *argp2 ;
97443   Dali::ImageDimensions result;
97444
97445   if (!jarg1) {
97446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97447     return 0;
97448   }
97449   std::string arg1_str(jarg1);
97450   arg1 = &arg1_str;
97451   argp2 = (Dali::ImageDimensions *)jarg2;
97452   if (!argp2) {
97453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97454     return 0;
97455   }
97456   arg2 = *argp2;
97457   arg3 = (Dali::FittingMode::Type)jarg3;
97458   arg4 = (Dali::SamplingMode::Type)jarg4;
97459   {
97460     try {
97461       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
97462     } catch (std::out_of_range& e) {
97463       {
97464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97465       };
97466     } catch (std::exception& e) {
97467       {
97468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97469       };
97470     } catch (...) {
97471       {
97472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97473       };
97474     }
97475   }
97476   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97477
97478   return jresult;
97479 }
97480
97481
97482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97483   void * jresult ;
97484   std::string *arg1 = 0 ;
97485   Dali::ImageDimensions arg2 ;
97486   Dali::FittingMode::Type arg3 ;
97487   Dali::ImageDimensions *argp2 ;
97488   Dali::ImageDimensions result;
97489
97490   if (!jarg1) {
97491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97492     return 0;
97493   }
97494   std::string arg1_str(jarg1);
97495   arg1 = &arg1_str;
97496   argp2 = (Dali::ImageDimensions *)jarg2;
97497   if (!argp2) {
97498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97499     return 0;
97500   }
97501   arg2 = *argp2;
97502   arg3 = (Dali::FittingMode::Type)jarg3;
97503   {
97504     try {
97505       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
97506     } catch (std::out_of_range& e) {
97507       {
97508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97509       };
97510     } catch (std::exception& e) {
97511       {
97512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97513       };
97514     } catch (...) {
97515       {
97516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97517       };
97518     }
97519   }
97520   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97521
97522   return jresult;
97523 }
97524
97525
97526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
97527   void * jresult ;
97528   std::string *arg1 = 0 ;
97529   Dali::ImageDimensions arg2 ;
97530   Dali::ImageDimensions *argp2 ;
97531   Dali::ImageDimensions result;
97532
97533   if (!jarg1) {
97534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97535     return 0;
97536   }
97537   std::string arg1_str(jarg1);
97538   arg1 = &arg1_str;
97539   argp2 = (Dali::ImageDimensions *)jarg2;
97540   if (!argp2) {
97541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97542     return 0;
97543   }
97544   arg2 = *argp2;
97545   {
97546     try {
97547       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
97548     } catch (std::out_of_range& e) {
97549       {
97550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97551       };
97552     } catch (std::exception& e) {
97553       {
97554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97555       };
97556     } catch (...) {
97557       {
97558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97559       };
97560     }
97561   }
97562   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97563
97564   return jresult;
97565 }
97566
97567
97568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
97569   void * jresult ;
97570   std::string *arg1 = 0 ;
97571   Dali::ImageDimensions result;
97572
97573   if (!jarg1) {
97574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97575     return 0;
97576   }
97577   std::string arg1_str(jarg1);
97578   arg1 = &arg1_str;
97579   {
97580     try {
97581       result = Dali::GetClosestImageSize((std::string const &)*arg1);
97582     } catch (std::out_of_range& e) {
97583       {
97584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97585       };
97586     } catch (std::exception& e) {
97587       {
97588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97589       };
97590     } catch (...) {
97591       {
97592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97593       };
97594     }
97595   }
97596   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97597
97598   return jresult;
97599 }
97600
97601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
97602   void * jresult ;
97603   std::string *arg1 = 0 ;
97604   Dali::ImageDimensions result;
97605
97606   if (!jarg1) {
97607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97608     return 0;
97609   }
97610   std::string arg1_str(jarg1);
97611   arg1 = &arg1_str;
97612   {
97613     try {
97614       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
97615     } catch (std::out_of_range& e) {
97616       {
97617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97618       };
97619     } catch (std::exception& e) {
97620       {
97621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97622       };
97623     } catch (...) {
97624       {
97625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97626       };
97627     }
97628   }
97629   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97630
97631   return jresult;
97632 }
97633
97634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97635   void * jresult ;
97636   std::string *arg1 = 0 ;
97637   Dali::ImageDimensions arg2 ;
97638   Dali::FittingMode::Type arg3 ;
97639   Dali::SamplingMode::Type arg4 ;
97640   bool arg5 ;
97641   Dali::ImageDimensions *argp2 ;
97642   Dali::Devel::PixelBuffer result;
97643
97644   if (!jarg1) {
97645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97646     return 0;
97647   }
97648   std::string arg1_str(jarg1);
97649   arg1 = &arg1_str;
97650   argp2 = (Dali::ImageDimensions *)jarg2;
97651   if (!argp2) {
97652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97653     return 0;
97654   }
97655   arg2 = *argp2;
97656   arg3 = (Dali::FittingMode::Type)jarg3;
97657   arg4 = (Dali::SamplingMode::Type)jarg4;
97658   arg5 = jarg5 ? true : false;
97659   {
97660     try {
97661       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97662     } catch (std::out_of_range& e) {
97663       {
97664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97665       };
97666     } catch (std::exception& e) {
97667       {
97668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97669       };
97670     } catch (...) {
97671       {
97672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97673       };
97674     }
97675   }
97676   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97677
97678   return jresult;
97679 }
97680
97681
97682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97683   void * jresult ;
97684   std::string *arg1 = 0 ;
97685   Dali::ImageDimensions arg2 ;
97686   Dali::FittingMode::Type arg3 ;
97687   Dali::SamplingMode::Type arg4 ;
97688   Dali::ImageDimensions *argp2 ;
97689   Dali::Devel::PixelBuffer result;
97690
97691   if (!jarg1) {
97692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97693     return 0;
97694   }
97695   std::string arg1_str(jarg1);
97696   arg1 = &arg1_str;
97697   argp2 = (Dali::ImageDimensions *)jarg2;
97698   if (!argp2) {
97699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97700     return 0;
97701   }
97702   arg2 = *argp2;
97703   arg3 = (Dali::FittingMode::Type)jarg3;
97704   arg4 = (Dali::SamplingMode::Type)jarg4;
97705   {
97706     try {
97707       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
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::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97723
97724   return jresult;
97725 }
97726
97727
97728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97729   void * jresult ;
97730   std::string *arg1 = 0 ;
97731   Dali::ImageDimensions arg2 ;
97732   Dali::FittingMode::Type arg3 ;
97733   Dali::ImageDimensions *argp2 ;
97734   Dali::Devel::PixelBuffer result;
97735
97736   if (!jarg1) {
97737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97738     return 0;
97739   }
97740   std::string arg1_str(jarg1);
97741   arg1 = &arg1_str;
97742   argp2 = (Dali::ImageDimensions *)jarg2;
97743   if (!argp2) {
97744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97745     return 0;
97746   }
97747   arg2 = *argp2;
97748   arg3 = (Dali::FittingMode::Type)jarg3;
97749   {
97750     try {
97751       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
97752     } catch (std::out_of_range& e) {
97753       {
97754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97755       };
97756     } catch (std::exception& e) {
97757       {
97758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97759       };
97760     } catch (...) {
97761       {
97762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97763       };
97764     }
97765   }
97766   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97767
97768   return jresult;
97769 }
97770
97771
97772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
97773   void * jresult ;
97774   std::string *arg1 = 0 ;
97775   Dali::ImageDimensions arg2 ;
97776   Dali::ImageDimensions *argp2 ;
97777   Dali::Devel::PixelBuffer result;
97778
97779   if (!jarg1) {
97780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97781     return 0;
97782   }
97783   std::string arg1_str(jarg1);
97784   arg1 = &arg1_str;
97785   argp2 = (Dali::ImageDimensions *)jarg2;
97786   if (!argp2) {
97787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97788     return 0;
97789   }
97790   arg2 = *argp2;
97791   {
97792     try {
97793       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
97794     } catch (std::out_of_range& e) {
97795       {
97796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97797       };
97798     } catch (std::exception& e) {
97799       {
97800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97801       };
97802     } catch (...) {
97803       {
97804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97805       };
97806     }
97807   }
97808   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97809
97810   return jresult;
97811 }
97812
97813
97814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
97815   void * jresult ;
97816   std::string *arg1 = 0 ;
97817   Dali::Devel::PixelBuffer result;
97818
97819   if (!jarg1) {
97820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97821     return 0;
97822   }
97823   std::string arg1_str(jarg1);
97824   arg1 = &arg1_str;
97825   {
97826     try {
97827       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
97828     } catch (std::out_of_range& e) {
97829       {
97830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97831       };
97832     } catch (std::exception& e) {
97833       {
97834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97835       };
97836     } catch (...) {
97837       {
97838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97839       };
97840     }
97841   }
97842   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97843
97844   return jresult;
97845 }
97846
97847
97848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
97849   void * jresult ;
97850   Dali::Toolkit::WebView result;
97851
97852   {
97853     try {
97854       result = Dali::Toolkit::WebView::New();
97855     } catch (std::out_of_range& e) {
97856       {
97857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97858       };
97859     } catch (std::exception& e) {
97860       {
97861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97862       };
97863     } catch (Dali::DaliException e) {
97864       {
97865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97866       };
97867     } catch (...) {
97868       {
97869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97870       };
97871     }
97872   }
97873   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
97874   return jresult;
97875 }
97876
97877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
97878   void * jresult ;
97879   Dali::Toolkit::WebView result;
97880
97881   std::string *arg1;
97882   std::string *arg2;
97883
97884   if (!jarg1) {
97885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
97886     return 0;
97887   }
97888   if (!jarg2) {
97889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
97890     return 0;
97891   }
97892
97893   std::string jarg1_str = std::string(jarg1);
97894   std::string jarg2_str = std::string(jarg2);
97895
97896   arg1 = &jarg1_str;
97897   arg2 = &jarg2_str;
97898
97899   {
97900     try {
97901       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
97902     } catch (std::out_of_range& e) {
97903       {
97904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97905       };
97906     } catch (std::exception& e) {
97907       {
97908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97909       };
97910     } catch (Dali::DaliException e) {
97911       {
97912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97913       };
97914     } catch (...) {
97915       {
97916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97917       };
97918     }
97919   }
97920   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
97921   return jresult;
97922 }
97923
97924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
97925   void * jresult ;
97926   Dali::Toolkit::WebView *arg1 = 0 ;
97927   Dali::Toolkit::WebView *result = 0 ;
97928
97929   arg1 = (Dali::Toolkit::WebView *)jarg1;
97930   if (!arg1) {
97931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
97932     return 0;
97933   }
97934   {
97935     try {
97936       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
97937     } catch (std::out_of_range& e) {
97938       {
97939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97940       };
97941     } catch (std::exception& e) {
97942       {
97943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97944       };
97945     } catch (Dali::DaliException e) {
97946       {
97947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97948       };
97949     } catch (...) {
97950       {
97951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97952       };
97953     }
97954   }
97955   jresult = (void *)result;
97956   return jresult;
97957 }
97958
97959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
97960   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
97961   arg1 = (Dali::Toolkit::WebView *)jarg1;
97962   {
97963     try {
97964       delete arg1;
97965     } catch (std::out_of_range& e) {
97966       {
97967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97968       };
97969     } catch (std::exception& e) {
97970       {
97971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97972       };
97973     } catch (Dali::DaliException e) {
97974       {
97975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97976       };
97977     } catch (...) {
97978       {
97979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97980       };
97981     }
97982   }
97983 }
97984
97985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
97986   void * jresult ;
97987   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
97988   Dali::Toolkit::WebView *arg2 = 0 ;
97989   Dali::Toolkit::WebView *result = 0 ;
97990
97991   arg1 = (Dali::Toolkit::WebView *)jarg1;
97992   arg2 = (Dali::Toolkit::WebView *)jarg2;
97993   if (!arg2) {
97994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
97995     return 0;
97996   }
97997   {
97998     try {
97999       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
98000     } catch (std::out_of_range& e) {
98001       {
98002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98003       };
98004     } catch (std::exception& e) {
98005       {
98006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98007       };
98008     } catch (Dali::DaliException e) {
98009       {
98010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98011       };
98012     } catch (...) {
98013       {
98014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98015       };
98016     }
98017   }
98018   jresult = (void *)result;
98019   return jresult;
98020 }
98021
98022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
98023   void * jresult ;
98024   Dali::BaseHandle arg1 ;
98025   Dali::BaseHandle *argp1 ;
98026   Dali::Toolkit::WebView result;
98027
98028   argp1 = (Dali::BaseHandle *)jarg1;
98029   if (!argp1) {
98030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
98031     return 0;
98032   }
98033   arg1 = *argp1;
98034   {
98035     try {
98036       result = Dali::Toolkit::WebView::DownCast(arg1);
98037     } catch (std::out_of_range& e) {
98038       {
98039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98040       };
98041     } catch (std::exception& e) {
98042       {
98043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98044       };
98045     } catch (Dali::DaliException e) {
98046       {
98047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98048       };
98049     } catch (...) {
98050       {
98051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98052       };
98053     }
98054   }
98055   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98056   return jresult;
98057 }
98058
98059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
98060   return (int) Dali::Toolkit::WebView::Property::URL;
98061 }
98062
98063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
98064   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
98065 }
98066
98067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
98068   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
98069 }
98070
98071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
98072   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
98073 }
98074
98075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
98076   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
98077 }
98078
98079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
98080   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
98081 }
98082
98083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
98084   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
98085 }
98086
98087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
98088   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
98089 }
98090
98091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
98092   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98093   std::string *arg2;
98094
98095   arg1 = (Dali::Toolkit::WebView *)jarg1;
98096
98097   if (!jarg2) {
98098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98099     return;
98100   }
98101
98102   std::string jarg2str = std::string(jarg2);
98103   arg2 = &jarg2str;
98104   {
98105     try {
98106       (arg1)->LoadUrl((std::string const &)*arg2);
98107     } catch (std::out_of_range& e) {
98108       {
98109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98110       };
98111     } catch (std::exception& e) {
98112       {
98113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98114       };
98115     } catch (Dali::DaliException e) {
98116       {
98117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98118       };
98119     } catch (...) {
98120       {
98121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98122       };
98123     }
98124   }
98125 }
98126
98127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
98128   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98129   std::string *arg2;
98130
98131   arg1 = (Dali::Toolkit::WebView *)jarg1;
98132   if (!jarg2) {
98133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98134     return;
98135   }
98136   std::string jarg2str = std::string(jarg2);
98137   arg2 = &jarg2str;
98138   {
98139     try {
98140       (arg1)->LoadHTMLString((std::string const &)*arg2);
98141     } catch (std::out_of_range& e) {
98142       {
98143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98144       };
98145     } catch (std::exception& e) {
98146       {
98147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98148       };
98149     } catch (Dali::DaliException e) {
98150       {
98151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98152       };
98153     } catch (...) {
98154       {
98155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98156       };
98157     }
98158   }
98159 }
98160
98161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
98162   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98163
98164   arg1 = (Dali::Toolkit::WebView *)jarg1;
98165   {
98166     try {
98167       (arg1)->Reload();
98168     } catch (std::out_of_range& e) {
98169       {
98170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98171       };
98172     } catch (std::exception& e) {
98173       {
98174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98175       };
98176     } catch (Dali::DaliException e) {
98177       {
98178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98179       };
98180     } catch (...) {
98181       {
98182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98183       };
98184     }
98185   }
98186 }
98187
98188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
98189   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98190
98191   arg1 = (Dali::Toolkit::WebView *)jarg1;
98192   {
98193     try {
98194       (arg1)->StopLoading();
98195     } catch (std::out_of_range& e) {
98196       {
98197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98198       };
98199     } catch (std::exception& e) {
98200       {
98201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98202       };
98203     } catch (Dali::DaliException e) {
98204       {
98205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98206       };
98207     } catch (...) {
98208       {
98209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98210       };
98211     }
98212   }
98213 }
98214
98215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
98216   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98217
98218   arg1 = (Dali::Toolkit::WebView *)jarg1;
98219   {
98220     try {
98221       (arg1)->Suspend();
98222     } catch (std::out_of_range& e) {
98223       {
98224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98225       };
98226     } catch (std::exception& e) {
98227       {
98228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98229       };
98230     } catch (Dali::DaliException e) {
98231       {
98232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98233       };
98234     } catch (...) {
98235       {
98236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98237       };
98238     }
98239   }
98240 }
98241
98242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
98243   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98244
98245   arg1 = (Dali::Toolkit::WebView *)jarg1;
98246   {
98247     try {
98248       (arg1)->Resume();
98249     } catch (std::out_of_range& e) {
98250       {
98251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98252       };
98253     } catch (std::exception& e) {
98254       {
98255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98256       };
98257     } catch (Dali::DaliException e) {
98258       {
98259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98260       };
98261     } catch (...) {
98262       {
98263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98264       };
98265     }
98266   }
98267 }
98268
98269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
98270   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98271
98272   arg1 = (Dali::Toolkit::WebView *)jarg1;
98273   {
98274     try {
98275       (arg1)->GoBack();
98276     } catch (std::out_of_range& e) {
98277       {
98278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98279       };
98280     } catch (std::exception& e) {
98281       {
98282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98283       };
98284     } catch (Dali::DaliException e) {
98285       {
98286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98287       };
98288     } catch (...) {
98289       {
98290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98291       };
98292     }
98293   }
98294 }
98295
98296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
98297   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98298
98299   arg1 = (Dali::Toolkit::WebView *)jarg1;
98300   {
98301     try {
98302       (arg1)->GoForward();
98303     } catch (std::out_of_range& e) {
98304       {
98305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98306       };
98307     } catch (std::exception& e) {
98308       {
98309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98310       };
98311     } catch (Dali::DaliException e) {
98312       {
98313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98314       };
98315     } catch (...) {
98316       {
98317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98318       };
98319     }
98320   }
98321 }
98322
98323 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
98324   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98325   bool ret;
98326
98327   arg1 = (Dali::Toolkit::WebView *)jarg1;
98328   {
98329     try {
98330       ret = (arg1)->CanGoBack();
98331     } catch (std::out_of_range& e) {
98332       {
98333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98334       };
98335     } catch (std::exception& e) {
98336       {
98337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98338       };
98339     } catch (Dali::DaliException e) {
98340       {
98341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98342       };
98343     } catch (...) {
98344       {
98345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98346       };
98347     }
98348   }
98349   return ret;
98350 }
98351
98352 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
98353   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98354   bool ret;
98355
98356   arg1 = (Dali::Toolkit::WebView *)jarg1;
98357   {
98358     try {
98359       ret = (arg1)->CanGoForward();
98360     } catch (std::out_of_range& e) {
98361       {
98362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98363       };
98364     } catch (std::exception& e) {
98365       {
98366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98367       };
98368     } catch (Dali::DaliException e) {
98369       {
98370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98371       };
98372     } catch (...) {
98373       {
98374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98375       };
98376     }
98377   }
98378   return ret;
98379 }
98380
98381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
98382   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98383   std::string *arg2;
98384
98385   arg1 = (Dali::Toolkit::WebView *)jarg1;
98386   if (!jarg2) {
98387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98388     return;
98389   }
98390   std::string jarg2_str = std::string(jarg2);
98391   arg2 = &jarg2_str;
98392
98393   {
98394     try {
98395       if (jarg3) {
98396         void (*handler)(char*) = (void (*)(char*)) jarg3;
98397         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
98398           handler(SWIG_csharp_string_callback(result.c_str()));
98399         });
98400       } else {
98401         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
98402       }
98403     } catch (std::out_of_range& e) {
98404       {
98405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98406       };
98407     } catch (std::exception& e) {
98408       {
98409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98410       };
98411     } catch (Dali::DaliException e) {
98412       {
98413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98414       };
98415     } catch (...) {
98416       {
98417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98418       };
98419     }
98420   }
98421 }
98422
98423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
98424 {
98425   if (!jarg2) {
98426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98427     return;
98428   }
98429
98430   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98431   std::string exposedObjectName = jarg2;
98432   void (*handler)(char*) = (void (*)(char*)) jarg3;
98433
98434   {
98435     try {
98436       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
98437         handler(SWIG_csharp_string_callback(message.c_str()));
98438       });
98439     } catch (std::out_of_range& e) {
98440       {
98441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98442       };
98443     } catch (std::exception& e) {
98444       {
98445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98446       };
98447     } catch (Dali::DaliException e) {
98448       {
98449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98450       };
98451     } catch (...) {
98452       {
98453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98454       };
98455     }
98456   }
98457 }
98458
98459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
98460   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98461
98462   arg1 = (Dali::Toolkit::WebView *)jarg1;
98463   {
98464     try {
98465       (arg1)->ClearHistory();
98466     } catch (std::out_of_range& e) {
98467       {
98468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98469       };
98470     } catch (std::exception& e) {
98471       {
98472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98473       };
98474     } catch (Dali::DaliException e) {
98475       {
98476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98477       };
98478     } catch (...) {
98479       {
98480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98481       };
98482     }
98483   }
98484 }
98485
98486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
98487   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98488
98489   arg1 = (Dali::Toolkit::WebView *)jarg1;
98490   {
98491     try {
98492       (arg1)->ClearCache();
98493     } catch (std::out_of_range& e) {
98494       {
98495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98496       };
98497     } catch (std::exception& e) {
98498       {
98499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98500       };
98501     } catch (Dali::DaliException e) {
98502       {
98503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98504       };
98505     } catch (...) {
98506       {
98507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98508       };
98509     }
98510   }
98511 }
98512
98513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
98514   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98515
98516   arg1 = (Dali::Toolkit::WebView *)jarg1;
98517   {
98518     try {
98519       (arg1)->ClearCookies();
98520     } catch (std::out_of_range& e) {
98521       {
98522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98523       };
98524     } catch (std::exception& e) {
98525       {
98526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98527       };
98528     } catch (Dali::DaliException e) {
98529       {
98530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98531       };
98532     } catch (...) {
98533       {
98534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98535       };
98536     }
98537   }
98538 }
98539
98540 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
98541     return (Dali::Toolkit::Control *)jarg1;
98542 }
98543
98544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
98545   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98546   SignalConverter::WebViewPageLoadSignal* result = NULL;
98547   {
98548     try {
98549       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
98550     } catch (std::out_of_range& e) {
98551       {
98552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98553       };
98554     } catch (std::exception& e) {
98555       {
98556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98557       };
98558     } catch (Dali::DaliException e) {
98559       {
98560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98561       };
98562     } catch (...) {
98563       {
98564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98565       };
98566     }
98567   }
98568   return (void*) result;
98569 }
98570
98571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
98572   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98573   SignalConverter::WebViewPageLoadSignal* result = NULL;
98574   {
98575     try {
98576       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
98577     } catch (std::out_of_range& e) {
98578       {
98579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98580       };
98581     } catch (std::exception& e) {
98582       {
98583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98584       };
98585     } catch (Dali::DaliException e) {
98586       {
98587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98588       };
98589     } catch (...) {
98590       {
98591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98592       };
98593     }
98594   }
98595   return (void*) result;
98596 }
98597
98598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
98599 {
98600   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98601   {
98602     try {
98603       delete object;
98604     } catch (std::out_of_range& e) {
98605       {
98606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98607       };
98608     } catch (std::exception& e) {
98609       {
98610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98611       };
98612     } catch (Dali::DaliException e) {
98613       {
98614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98615       };
98616     } catch (...) {
98617       {
98618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98619       };
98620     }
98621   }
98622 }
98623
98624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
98625 {
98626   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98627   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98628   {
98629     try {
98630       proxy->Connect(callback);
98631     } catch (std::out_of_range& e) {
98632       {
98633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98634       };
98635     } catch (std::exception& e) {
98636       {
98637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98638       };
98639     } catch (Dali::DaliException e) {
98640       {
98641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98642       };
98643     } catch (...) {
98644       {
98645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98646       };
98647     }
98648   }
98649 }
98650
98651
98652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
98653   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98654   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98655   {
98656     try {
98657       proxy->Disconnect(callback);
98658     } catch (std::out_of_range& e) {
98659       {
98660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98661       };
98662     } catch (std::exception& e) {
98663       {
98664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98665       };
98666     } catch (Dali::DaliException e) {
98667       {
98668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98669       };
98670     } catch (...) {
98671       {
98672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98673       };
98674     }
98675   }
98676 }
98677
98678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
98679   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98680   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
98681   {
98682     try {
98683       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
98684     } catch (std::out_of_range& e) {
98685       {
98686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98687       };
98688     } catch (std::exception& e) {
98689       {
98690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98691       };
98692     } catch (Dali::DaliException e) {
98693       {
98694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98695       };
98696     } catch (...) {
98697       {
98698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98699       };
98700     }
98701   }
98702   return (void*) result;
98703 }
98704
98705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
98706 {
98707   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98708   {
98709     try {
98710       delete object;
98711     } catch (std::out_of_range& e) {
98712       {
98713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98714       };
98715     } catch (std::exception& e) {
98716       {
98717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98718       };
98719     } catch (Dali::DaliException e) {
98720       {
98721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98722       };
98723     } catch (...) {
98724       {
98725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98726       };
98727     }
98728   }
98729 }
98730
98731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
98732 {
98733   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98734   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
98735   {
98736     try {
98737       proxy->Connect(callback);
98738     } catch (std::out_of_range& e) {
98739       {
98740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98741       };
98742     } catch (std::exception& e) {
98743       {
98744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98745       };
98746     } catch (Dali::DaliException e) {
98747       {
98748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98749       };
98750     } catch (...) {
98751       {
98752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98753       };
98754     }
98755   }
98756 }
98757
98758
98759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
98760   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98761   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
98762   {
98763     try {
98764       proxy->Disconnect(callback);
98765     } catch (std::out_of_range& e) {
98766       {
98767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98768       };
98769     } catch (std::exception& e) {
98770       {
98771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98772       };
98773     } catch (Dali::DaliException e) {
98774       {
98775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98776       };
98777     } catch (...) {
98778       {
98779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98780       };
98781     }
98782   }
98783 }
98784
98785 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
98786   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
98787   char * jresult = SWIG_csharp_string_callback((const char *)result);
98788   return jresult;
98789 }
98790
98791 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
98792   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
98793   return result;
98794 }
98795
98796
98797 struct NativeImageSourcePtrHandle
98798 {
98799   NativeImageSourcePtr Ptr;
98800 };
98801
98802 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
98803 {
98804   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98805   return (NativeImageInterface*)(arg1);
98806 }
98807
98808 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
98809 {
98810   void* jresult;
98811   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
98812   {
98813     try {
98814       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
98815     }
98816     catch (std::out_of_range & e) {
98817       {
98818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98819       };
98820     }
98821     catch (std::exception & e) {
98822       {
98823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98824       };
98825     }
98826     catch (Dali::DaliException e) {
98827       {
98828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98829       };
98830     }
98831     catch (...) {
98832       {
98833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98834       };
98835     }
98836   }
98837   jresult = (void *)handle;
98838   return jresult;
98839 }
98840
98841 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
98842 {
98843   void* jresult;
98844   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
98845   jresult = (void*)( handle->Ptr.Get() );
98846   return jresult;
98847 }
98848
98849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
98850   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
98851   {
98852     try {
98853       delete arg1;
98854     }
98855     catch (std::out_of_range & e) {
98856       {
98857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
98858       };
98859     }
98860     catch (std::exception & e) {
98861       {
98862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
98863       };
98864     }
98865     catch (Dali::DaliException e) {
98866       {
98867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
98868       };
98869     }
98870     catch (...) {
98871       {
98872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
98873       };
98874     }
98875   }
98876 }
98877
98878 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
98879 {
98880   void* jresult;
98881   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98882   uint16_t* arg2 = (uint16_t*)(jarg2);
98883   uint16_t* arg3 = (uint16_t*)(jarg3);
98884   uint16_t* arg4 = (uint16_t*)(jarg4);
98885   {
98886     try {
98887       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
98888     }
98889     catch (std::out_of_range & e) {
98890       {
98891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98892       };
98893     }
98894     catch (std::exception & e) {
98895       {
98896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98897       };
98898     }
98899     catch (Dali::DaliException e) {
98900       {
98901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98902       };
98903     }
98904     catch (...) {
98905       {
98906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98907       };
98908     }
98909   }
98910   return jresult;
98911 }
98912
98913 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
98914 {
98915   bool jresult;
98916   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98917
98918   {
98919     try {
98920       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
98921     }
98922     catch (std::out_of_range & e) {
98923       {
98924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98925       };
98926     }
98927     catch (std::exception & e) {
98928       {
98929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98930       };
98931     }
98932     catch (Dali::DaliException e) {
98933       {
98934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98935       };
98936     }
98937     catch (...) {
98938       {
98939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98940       };
98941     }
98942   }
98943   return jresult;
98944 }
98945
98946
98947 #ifdef __cplusplus
98948 }
98949 #endif